{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import nltk\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from nltk.stem import WordNetLemmatizer\n",
    "from nltk.corpus import wordnet\n",
    "import re, collections\n",
    "from collections import defaultdict\n",
    "from sklearn.feature_extraction.text import CountVectorizer\n",
    "from sklearn.metrics import mean_squared_error, r2_score\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.linear_model import LinearRegression, Ridge, Lasso\n",
    "from sklearn import ensemble\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "import xgboost as xgb\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "os.environ['KMP_DUPLICATE_LIB_OK'] = 'TRUE'\n",
    "os.environ['CUDA_VISIBLE_DEVICES'] = '1'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 读取数据"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "essay_csv = \"essay_test.csv\"\n",
    "# 读取数据\n",
    "#dataframe = pd.read_csv('essays_and_scores.csv', encoding = 'latin-1')\n",
    "\n",
    "dataframe = pd.read_csv(essay_csv, encoding = 'latin-1')\n",
    "#copy一份数据\n",
    "data = dataframe[['id','essay','score']].copy()\n",
    "#print(data.head(10))\n",
    "# 查看数据是否有缺失值，可以看出是没有的\n",
    "#data.info()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 探索数据"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>id</th>\n",
       "      <th>essay</th>\n",
       "      <th>score</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>10001</td>\n",
       "      <td>Dear Jerry. I've heard about that you will giv...</td>\n",
       "      <td>19.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>10002</td>\n",
       "      <td>Dear Jerry I'm glad that you'll respresent you...</td>\n",
       "      <td>16.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>10003</td>\n",
       "      <td>Dear Jerry, I am very happy to hear that you w...</td>\n",
       "      <td>20.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>10004</td>\n",
       "      <td>Dear Je I'm so happy to hear that you will hav...</td>\n",
       "      <td>15.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>10005</td>\n",
       "      <td>Dear Jerry, I am so glad to hear that you will...</td>\n",
       "      <td>19.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>996</th>\n",
       "      <td>11045</td>\n",
       "      <td>Dear Jerry, First, you must know how and what ...</td>\n",
       "      <td>17.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>997</th>\n",
       "      <td>11046</td>\n",
       "      <td>Dear Jerry, Yours, Li Hua</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>998</th>\n",
       "      <td>11047</td>\n",
       "      <td>Dear Jerry, Yours, Li Hua</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>999</th>\n",
       "      <td>11048</td>\n",
       "      <td>Dear Jerry, Yours, Li Hua</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1000</th>\n",
       "      <td>11049</td>\n",
       "      <td>Dear Jerry, Yours, Li Hua</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>1001 rows × 3 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "         id                                              essay  score\n",
       "0     10001  Dear Jerry. I've heard about that you will giv...   19.5\n",
       "1     10002  Dear Jerry I'm glad that you'll respresent you...   16.5\n",
       "2     10003  Dear Jerry, I am very happy to hear that you w...   20.5\n",
       "3     10004  Dear Je I'm so happy to hear that you will hav...   15.5\n",
       "4     10005  Dear Jerry, I am so glad to hear that you will...   19.0\n",
       "...     ...                                                ...    ...\n",
       "996   11045  Dear Jerry, First, you must know how and what ...   17.5\n",
       "997   11046                          Dear Jerry, Yours, Li Hua    0.0\n",
       "998   11047                          Dear Jerry, Yours, Li Hua    0.0\n",
       "999   11048                          Dear Jerry, Yours, Li Hua    0.0\n",
       "1000  11049                          Dear Jerry, Yours, Li Hua    0.0\n",
       "\n",
       "[1001 rows x 3 columns]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 转化成dataframe看一下数据是什么样子\n",
    "pd.DataFrame(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#把score列转换为列表\n",
    "scores = data[\"score\"]\n",
    "scores = [*scores]\n",
    "scores\n",
    "type(scores)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "count    1001.000000\n",
       "mean       15.324176\n",
       "std         4.992700\n",
       "min         0.000000\n",
       "25%        14.000000\n",
       "50%        16.500000\n",
       "75%        18.500000\n",
       "max        23.000000\n",
       "Name: score, dtype: float64"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 绘制分数分布图& describe数据信息\n",
    "plt.figure() #初始化一张图\n",
    "x = scores\n",
    "plt.hist(x)  #直方图关键操作\n",
    "plt.grid(alpha=0.5,linestyle='-.') #网格线，更好看 \n",
    "plt.xlabel('scores')  \n",
    "plt.show()\n",
    "data[\"score\"].describe()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 向量特征"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 统计文章中每篇文章的词频分布\n",
    "def get_count_vectors(essays):\n",
    "    # 实例化vectorizer\n",
    "    '''\n",
    "    CountVectorizer是属于常见的特征数值计算类，是一个文本特征提取方法。\n",
    "    # 对于每一个训练文本，它只考虑每种词汇在该训练文本中出现的频率。ngram_range表示词组切分的长度范围\n",
    "    #设置停用词，设为english将使用内置的英语停用词，设为一个list可自定义停用词,设为None不使用停用词，设为None且max_df∈[0.7, 1.0)将自动根据当前的语料库建立停用词表\n",
    "    max_features默认为None，可设为int，对所有关键词的term frequency进行降序排序，只取前max_features个作为关键词集\n",
    "    '''\n",
    "    vectorizer = CountVectorizer(max_features=10000, ngram_range=(1, 3), stop_words='english')\n",
    "    #fit_transform(X)\t拟合模型，并返回文本矩阵\n",
    "    count_vectors = vectorizer.fit_transform(essays)\n",
    "    # get_feature_names()\t所有文本的词汇；列表型\n",
    "    feature_names = vectorizer.get_feature_names()\n",
    "    vocabulary = vectorizer.vocabulary_\n",
    "    return feature_names, count_vectors,vocabulary\n",
    "\n",
    "#返回essay的文章的文本矩阵和关键词列表\n",
    "feature_names_cv, count_vectors,vocabulary = get_count_vectors(data[\"essay\"])\n",
    "\n",
    "# vocabulary2 = sorted(vocabulary.items(),key = lambda x:x[0])\n",
    "# print(vocabulary2)\n",
    "\n",
    "#通过toarray()可看到词频矩阵的结果\n",
    "'''\n",
    "这里的x是词频矩阵，类似于以下这种，y 是总得分（也就是使用词频来预测得分）\n",
    "#[[0 1 1 1]\n",
    "# [0 2 1 0]\n",
    "# [1 0 0 1]\n",
    "# [1 0 0 0]]\n",
    "'''\n",
    "# 拿到特征和评分\n",
    "X_cv = count_vectors.toarray()\n",
    "y_cv = data[\"score\"].values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 划分训练集与测试集"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 划分训练集和测试集\n",
    "X_train, X_test, y_train, y_test = train_test_split(X_cv, y_cv, test_size = 0.3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 线性回归与岭回归模型训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "测试集准确度： \n",
      " 0.4057503513910502\n",
      "LinearRegression Coefficients: \n",
      " [ 0.13891626  0.2244723  -0.27783535 ... -0.08328568  0.05694957\n",
      " -0.06180618]\n",
      "LinearRegression Mean squared error: 13.35\n",
      "--------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "#实例化线性回归\n",
    "\n",
    "linear_regressor = LinearRegression()\n",
    "linear_regressor.fit(X_train, y_train)\n",
    "y_pred = linear_regressor.predict(X_test)\n",
    "print(\"测试集准确度：\",\"\\n\",linear_regressor.score(X_test,y_test))\n",
    "#print(linear_regressor.score)\n",
    "# The coefficients\n",
    "#构建训练集和特征集。利用线性回归和岭回归进行训练，两者差距不大。\n",
    "print('LinearRegression Coefficients: \\n', linear_regressor.coef_)\n",
    "# The mean squared error\n",
    "#均方误差，没有开根号\n",
    "print(\"LinearRegression Mean squared error: %.2f\" % mean_squared_error(y_test, y_pred))\n",
    "#绝对值差\n",
    "#print('LinearRegression MAPE:%.2f' % np.average(np.abs((y_test-y_pred)/y_test)))\n",
    "print('-' * 50)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "测试集准确度： \n",
      " 0.42220142527171023\n",
      "Ridge Coefficients: \n",
      " [ 0.13978696  0.15336255 -0.151187   ... -0.07674654  0.05752454\n",
      " -0.05459834]\n",
      "Ridge Mean squared error: 12.98\n",
      "--------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "#岭回归在多元线性回归的损失函数上加上了正则项，表达为系数 的L2范式（即系数 的平方项）乘以正则化系数，可以看出ridge的结果好一些\n",
    "ridge = Ridge(alpha=1.0,random_state=100)\n",
    "ridge.fit(X_train, y_train)\n",
    "y_pred = ridge.predict(X_test)\n",
    "\n",
    "print(\"测试集准确度：\",\"\\n\",ridge.score(X_test,y_test))\n",
    "print('Ridge Coefficients: \\n', ridge.coef_)\n",
    "print(\"Ridge Mean squared error: %.2f\" % mean_squared_error(y_test, y_pred))\n",
    "#print('Ridge MAPE:%.2f' % np.average(np.abs((y_test-y_pred)/y_test)))\n",
    "print('-' * 50)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 尝试其他的语言信息\n",
    "## 1. 对句子进行分词"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "example = '''Dear J I am very happy that you will have a English saying for high school students,\n",
    "           but I think it is difficult, I have some advice hope can help you to do it better. \n",
    "           This time, you must prepare for saying, you need to remember what you want to say.\n",
    "           You must find messages online so that you can finish the job better. \n",
    "           It is a practive for you, so you need let it became very important, so that you can treat it better. \n",
    "           When you finish the preparement, you have to let you relax, so that you have a result better. \n",
    "           When you go on, you not only have mouth, but also have hand, this can help you get better score. \n",
    "           In ground, you should do more act with your hands, because it can help you are not embarram.\n",
    "           Last, when you leave, you should say,  Thanks , then go out politely, Yours,\n",
    "           '''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sentence_to_wordlist(raw_sentence):\n",
    "    #句子清洗\n",
    "    # re的用法：replacedStr = re.sub(\"\\d+\", \"222\", inputStr)\n",
    "    clean_sentence = re.sub(\"[^a-zA-Z0-9]\", \" \", raw_sentence)# 这里主要是去除除了a-zA-Z0-9之外的字符\n",
    "    #nltk 分词\n",
    "    tokens = nltk.word_tokenize(clean_sentence)\n",
    "    #返回分词的结果\n",
    "    return tokens"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Dear',\n",
       " 'J',\n",
       " 'I',\n",
       " 'am',\n",
       " 'very',\n",
       " 'happy',\n",
       " 'that',\n",
       " 'you',\n",
       " 'will',\n",
       " 'have',\n",
       " 'a',\n",
       " 'English',\n",
       " 'saying',\n",
       " 'for',\n",
       " 'high',\n",
       " 'school',\n",
       " 'students',\n",
       " 'but',\n",
       " 'I',\n",
       " 'think',\n",
       " 'it',\n",
       " 'is',\n",
       " 'difficult',\n",
       " 'I',\n",
       " 'have',\n",
       " 'some',\n",
       " 'advice',\n",
       " 'hope',\n",
       " 'can',\n",
       " 'help',\n",
       " 'you',\n",
       " 'to',\n",
       " 'do',\n",
       " 'it',\n",
       " 'better',\n",
       " 'This',\n",
       " 'time',\n",
       " 'you',\n",
       " 'must',\n",
       " 'prepare',\n",
       " 'for',\n",
       " 'saying',\n",
       " 'you',\n",
       " 'need',\n",
       " 'to',\n",
       " 'remember',\n",
       " 'what',\n",
       " 'you',\n",
       " 'want',\n",
       " 'to',\n",
       " 'say',\n",
       " 'You',\n",
       " 'must',\n",
       " 'find',\n",
       " 'messages',\n",
       " 'online',\n",
       " 'so',\n",
       " 'that',\n",
       " 'you',\n",
       " 'can',\n",
       " 'finish',\n",
       " 'the',\n",
       " 'job',\n",
       " 'better',\n",
       " 'It',\n",
       " 'is',\n",
       " 'a',\n",
       " 'practive',\n",
       " 'for',\n",
       " 'you',\n",
       " 'so',\n",
       " 'you',\n",
       " 'need',\n",
       " 'let',\n",
       " 'it',\n",
       " 'became',\n",
       " 'very',\n",
       " 'important',\n",
       " 'so',\n",
       " 'that',\n",
       " 'you',\n",
       " 'can',\n",
       " 'treat',\n",
       " 'it',\n",
       " 'better',\n",
       " 'When',\n",
       " 'you',\n",
       " 'finish',\n",
       " 'the',\n",
       " 'preparement',\n",
       " 'you',\n",
       " 'have',\n",
       " 'to',\n",
       " 'let',\n",
       " 'you',\n",
       " 'relax',\n",
       " 'so',\n",
       " 'that',\n",
       " 'you',\n",
       " 'have',\n",
       " 'a',\n",
       " 'result',\n",
       " 'better',\n",
       " 'When',\n",
       " 'you',\n",
       " 'go',\n",
       " 'on',\n",
       " 'you',\n",
       " 'not',\n",
       " 'only',\n",
       " 'have',\n",
       " 'mouth',\n",
       " 'but',\n",
       " 'also',\n",
       " 'have',\n",
       " 'hand',\n",
       " 'this',\n",
       " 'can',\n",
       " 'help',\n",
       " 'you',\n",
       " 'get',\n",
       " 'better',\n",
       " 'score',\n",
       " 'In',\n",
       " 'ground',\n",
       " 'you',\n",
       " 'should',\n",
       " 'do',\n",
       " 'more',\n",
       " 'act',\n",
       " 'with',\n",
       " 'your',\n",
       " 'hands',\n",
       " 'because',\n",
       " 'it',\n",
       " 'can',\n",
       " 'help',\n",
       " 'you',\n",
       " 'are',\n",
       " 'not',\n",
       " 'embarram',\n",
       " 'Last',\n",
       " 'when',\n",
       " 'you',\n",
       " 'leave',\n",
       " 'you',\n",
       " 'should',\n",
       " 'say',\n",
       " 'Thanks',\n",
       " 'then',\n",
       " 'go',\n",
       " 'out',\n",
       " 'politely',\n",
       " 'Yours']"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sentence_to_wordlist(example)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.先分句，然后按照句子分词"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def tokenize(essay):\n",
    "    # 去掉句子前后空格\n",
    "    stripped_essay = essay.strip()\n",
    "    tokenizer = nltk.data.load('tokenizers/punkt/english.pickle')\n",
    "    raw_sentences = tokenizer.tokenize(stripped_essay) # 分句\n",
    "    #print(raw_sentences)\n",
    "    tokenized_sentences = []\n",
    "    for raw_sentence in raw_sentences:\n",
    "        if len(raw_sentence) > 0:\n",
    "            tokenized_sentences.append(sentence_to_wordlist(raw_sentence))\n",
    "    return tokenized_sentences"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[['Dear',\n",
       "  'J',\n",
       "  'I',\n",
       "  'am',\n",
       "  'very',\n",
       "  'happy',\n",
       "  'that',\n",
       "  'you',\n",
       "  'will',\n",
       "  'have',\n",
       "  'a',\n",
       "  'English',\n",
       "  'saying',\n",
       "  'for',\n",
       "  'high',\n",
       "  'school',\n",
       "  'students',\n",
       "  'but',\n",
       "  'I',\n",
       "  'think',\n",
       "  'it',\n",
       "  'is',\n",
       "  'difficult',\n",
       "  'I',\n",
       "  'have',\n",
       "  'some',\n",
       "  'advice',\n",
       "  'hope',\n",
       "  'can',\n",
       "  'help',\n",
       "  'you',\n",
       "  'to',\n",
       "  'do',\n",
       "  'it',\n",
       "  'better'],\n",
       " ['This',\n",
       "  'time',\n",
       "  'you',\n",
       "  'must',\n",
       "  'prepare',\n",
       "  'for',\n",
       "  'saying',\n",
       "  'you',\n",
       "  'need',\n",
       "  'to',\n",
       "  'remember',\n",
       "  'what',\n",
       "  'you',\n",
       "  'want',\n",
       "  'to',\n",
       "  'say'],\n",
       " ['You',\n",
       "  'must',\n",
       "  'find',\n",
       "  'messages',\n",
       "  'online',\n",
       "  'so',\n",
       "  'that',\n",
       "  'you',\n",
       "  'can',\n",
       "  'finish',\n",
       "  'the',\n",
       "  'job',\n",
       "  'better'],\n",
       " ['It',\n",
       "  'is',\n",
       "  'a',\n",
       "  'practive',\n",
       "  'for',\n",
       "  'you',\n",
       "  'so',\n",
       "  'you',\n",
       "  'need',\n",
       "  'let',\n",
       "  'it',\n",
       "  'became',\n",
       "  'very',\n",
       "  'important',\n",
       "  'so',\n",
       "  'that',\n",
       "  'you',\n",
       "  'can',\n",
       "  'treat',\n",
       "  'it',\n",
       "  'better'],\n",
       " ['When',\n",
       "  'you',\n",
       "  'finish',\n",
       "  'the',\n",
       "  'preparement',\n",
       "  'you',\n",
       "  'have',\n",
       "  'to',\n",
       "  'let',\n",
       "  'you',\n",
       "  'relax',\n",
       "  'so',\n",
       "  'that',\n",
       "  'you',\n",
       "  'have',\n",
       "  'a',\n",
       "  'result',\n",
       "  'better'],\n",
       " ['When',\n",
       "  'you',\n",
       "  'go',\n",
       "  'on',\n",
       "  'you',\n",
       "  'not',\n",
       "  'only',\n",
       "  'have',\n",
       "  'mouth',\n",
       "  'but',\n",
       "  'also',\n",
       "  'have',\n",
       "  'hand',\n",
       "  'this',\n",
       "  'can',\n",
       "  'help',\n",
       "  'you',\n",
       "  'get',\n",
       "  'better',\n",
       "  'score'],\n",
       " ['In',\n",
       "  'ground',\n",
       "  'you',\n",
       "  'should',\n",
       "  'do',\n",
       "  'more',\n",
       "  'act',\n",
       "  'with',\n",
       "  'your',\n",
       "  'hands',\n",
       "  'because',\n",
       "  'it',\n",
       "  'can',\n",
       "  'help',\n",
       "  'you',\n",
       "  'are',\n",
       "  'not',\n",
       "  'embarram'],\n",
       " ['Last',\n",
       "  'when',\n",
       "  'you',\n",
       "  'leave',\n",
       "  'you',\n",
       "  'should',\n",
       "  'say',\n",
       "  'Thanks',\n",
       "  'then',\n",
       "  'go',\n",
       "  'out',\n",
       "  'politely',\n",
       "  'Yours']]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tokenize(example)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.每个单词平均有几个字母\n",
    "## 输入essay，返回每个单词平均有几个字母"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def avg_word_len(essay):\n",
    "    # 清洗文章\n",
    "    clean_essay = re.sub(r'\\W', ' ', essay)\n",
    "    # 分词\n",
    "    words = nltk.word_tokenize(clean_essay)\n",
    "    # 遍历word，然后把每一个word的单词数目相加，然后除以总的单词数目，即可得到 每个单词平均有几个字母\n",
    "    return sum(len(word) for word in words) / len(words)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.896103896103896"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    " avg_word_len(example)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.文章单词总数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def word_count(essay):\n",
    "    clean_essay = re.sub(r'\\W', ' ', essay)\n",
    "    words = nltk.word_tokenize(clean_essay)\n",
    "    return len(words)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "154"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "word_count(example)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5.文章字母总数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def char_count(essay):\n",
    "    # 删除空格即返回文章字母总数\n",
    "    clean_essay = re.sub(r'\\s', '', str(essay).lower())\n",
    "    return len(clean_essay)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "626"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "char_count(example)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6.文章句子总数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sent_count(essay):\n",
    "    sentences = nltk.sent_tokenize(essay)\n",
    "    return len(sentences)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sent_count(example)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 7.统计词形还原后的单词总数,也就是总共有多少不同的单词-词汇丰富度"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "def count_lemmas(essay):\n",
    "    #分句\n",
    "    tokenized_sentences = tokenize(essay)\n",
    "    lemmas = []\n",
    "    wordnet_lemmatizer = WordNetLemmatizer()\n",
    "\n",
    "    for sentence in tokenized_sentences:\n",
    "        tagged_tokens = nltk.pos_tag(sentence)\n",
    "        #print(tagged_tokens)\n",
    "        for token_tuple in tagged_tokens:\n",
    "            pos_tag = token_tuple[1]\n",
    "            if pos_tag.startswith('N'):\n",
    "                pos = wordnet.NOUN\n",
    "                lemmas.append(wordnet_lemmatizer.lemmatize(token_tuple[0], pos))\n",
    "                #print(wordnet_lemmatizer.lemmatize(token_tuple[0], pos))\n",
    "            elif pos_tag.startswith('J'):\n",
    "                pos = wordnet.ADJ\n",
    "                lemmas.append(wordnet_lemmatizer.lemmatize(token_tuple[0], pos))\n",
    "            elif pos_tag.startswith('V'):\n",
    "                pos = wordnet.VERB\n",
    "                lemmas.append(wordnet_lemmatizer.lemmatize(token_tuple[0], pos))\n",
    "            elif pos_tag.startswith('R'):\n",
    "                pos = wordnet.ADV\n",
    "                lemmas.append(wordnet_lemmatizer.lemmatize(token_tuple[0], pos))\n",
    "            else:\n",
    "                pos = wordnet.NOUN\n",
    "                lemmas.append(wordnet_lemmatizer.lemmatize(token_tuple[0], pos))\n",
    "    lemma_count = len(set(lemmas))\n",
    "    # print(lemma_count)\n",
    "    return lemma_count"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "84"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "count_lemmas(example)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "# tokenized_sentences = tokenize(example)\n",
    "# wordnet_lemmatizer = WordNetLemmatizer()\n",
    "\n",
    "# for sentence in tokenized_sentences:\n",
    "#     tagged_tokens = nltk.pos_tag(sentence)\n",
    "#     print(tagged_tokens)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8.文章中错误单词总数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "def count_spell_error(essay):\n",
    "    clean_essay = re.sub(r'\\W', ' ', str(essay).lower())\n",
    "    clean_essay = re.sub(r'[0-9]', '', clean_essay)\n",
    "\n",
    "    # big.txt: It is a concatenation of public domain book excerpts from Project Gutenberg\n",
    "    #         and lists of most frequent words from Wiktionary and the British National Corpus.\n",
    "    #         It contains about a million words.\n",
    "    data = open('big.txt').read()\n",
    "\n",
    "    words_ = re.findall('[a-z]+', data.lower())\n",
    "\n",
    "\n",
    "    word_dict = collections.defaultdict(lambda: 0)\n",
    "\n",
    "    for word in words_:\n",
    "        word_dict[word] += 1\n",
    "\n",
    "    clean_essay = re.sub(r'\\W', ' ', str(essay).lower())\n",
    "    clean_essay = re.sub(r'[0-9]', '', clean_essay)\n",
    "\n",
    "    mispell_count = 0\n",
    "\n",
    "    words = clean_essay.split()\n",
    "\n",
    "    for word in words:\n",
    "        # 如果essay中的词汇不在big data 这个文件下，那么就认为这个单词拼写错了\n",
    "        if not word in word_dict:\n",
    "            mispell_count += 1\n",
    "\n",
    "    return mispell_count"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "count_spell_error(example)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 9.统计名词，动词，形容词和副词的数量"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "def count_pos(essay):\n",
    "    tokenized_sentences = tokenize(essay)\n",
    "\n",
    "    noun_count = 0\n",
    "    adj_count = 0\n",
    "    verb_count = 0\n",
    "    adv_count = 0\n",
    "\n",
    "    for sentence in tokenized_sentences:\n",
    "        tagged_tokens = nltk.pos_tag(sentence)\n",
    "\n",
    "        for token_tuple in tagged_tokens:\n",
    "            pos_tag = token_tuple[1]\n",
    "\n",
    "            if pos_tag.startswith('N'):\n",
    "                noun_count += 1\n",
    "            elif pos_tag.startswith('J'):\n",
    "                adj_count += 1\n",
    "            elif pos_tag.startswith('V'):\n",
    "                verb_count += 1\n",
    "            elif pos_tag.startswith('R'):\n",
    "                adv_count += 1\n",
    "\n",
    "    return noun_count, adj_count, verb_count, adv_count"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(18, 11, 40, 14)"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "count_pos(example)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 10.统计文章中每篇文章的词频-文本向量"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_count_vectors(essays):\n",
    "    vectorizer = CountVectorizer(max_features=10000, ngram_range=(1, 3), stop_words='english')\n",
    "\n",
    "    count_vectors = vectorizer.fit_transform(essays)\n",
    "\n",
    "    feature_names = vectorizer.get_feature_names()\n",
    "\n",
    "    return feature_names, count_vectors"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 11. 统计文章中连词的个数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "def count_conj(essay):\n",
    "    tokenized_sentences = tokenize(essay)\n",
    "\n",
    "    conj_count = 0\n",
    "    ps_conj = 0\n",
    "\n",
    "    for sentence in tokenized_sentences:\n",
    "        tagged_tokens = nltk.pos_tag(sentence)\n",
    "\n",
    "        for token_tuple in tagged_tokens:\n",
    "            pos_tag = token_tuple[1]\n",
    "            \n",
    "            if pos_tag.startswith('C'):\n",
    "                conj_count += 1\n",
    "            if pos_tag.startswith(\"IN\"):\n",
    "                ps_conj += 1\n",
    "    return conj_count,ps_conj"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 12)"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "count_conj(example)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 一个总的函数，构建文章的特征 输入的 data 就是essay"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "def extract_features(data):\n",
    "    features = data.copy()\n",
    "\n",
    "    features['char_count'] = features['essay'].apply(char_count) #文章字母总数\n",
    "    features['word_count'] = features['essay'].apply(word_count) #文章单词总数\n",
    "    features['sent_count'] = features['essay'].apply(sent_count) #文章句子总数\n",
    "    features['avg_word_len'] = features['essay'].apply(avg_word_len) #平均单词长度\n",
    "    features['lemma_count'] = features['essay'].apply(count_lemmas) # 文章词性统计\n",
    "    features['spell_err_count'] = features['essay'].apply(count_spell_error) # 文章写错的单词总数\n",
    "    features['noun_count'], features['adj_count'], features['verb_count'], features['adv_count'] = zip(\n",
    "        *features['essay'].map(count_pos)) # 文章名词  动词 形容词 副词的总数\n",
    "    features[\"conj\"], features[\"ps_conj\"] = zip(*features[\"essay\"].map(count_conj)) #连词的总数\n",
    "    return features\n",
    "\n",
    "#拿到特征\n",
    "features = extract_features(data)\n",
    "#print(features.columns)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 绘制散点图 表示各向量与score的关系"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:xlabel='ps_conj', ylabel='score'>"
      ]
     },
     "execution_count": 182,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 参数s表示散点的面积\n",
    "features.plot.scatter(x = 'char_count', y = 'score', s=10)\n",
    "features.plot.scatter(x = 'word_count', y = 'score', s=10)\n",
    "features.plot.scatter(x = 'sent_count', y = 'score', s=10)\n",
    "features.plot.scatter(x = 'avg_word_len', y = 'score', s=10)\n",
    "features.plot.scatter(x = 'lemma_count', y = 'score', s=10)\n",
    "features.plot.scatter(x = 'spell_err_count', y = 'score', s=10)\n",
    "features.plot.scatter(x = 'noun_count', y = 'score', s=10)\n",
    "features.plot.scatter(x = 'adj_count', y = 'score', s=10)\n",
    "features.plot.scatter(x = 'verb_count', y = 'score', s=10)\n",
    "features.plot.scatter(x = 'adv_count', y = 'score', s=10)\n",
    "features.plot.scatter(x = 'conj', y = 'score', s=10)\n",
    "features.plot.scatter(x = 'ps_conj', y = 'score', s=10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 计算特征与y之间的spearman 相关系数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = len(features['char_count'] )\n",
    "scores = features[\"score\"]\n",
    "char_count = features['char_count'].corr(scores,method=\"spearman\")\n",
    "word_count = features['word_count'].corr(scores,method=\"spearman\")\n",
    "sent_count = features['sent_count'].corr(scores,method=\"spearman\")\n",
    "avg_word_len = features['avg_word_len'].corr(scores,method=\"spearman\")\n",
    "lemma_count = features['lemma_count'].corr(scores,method=\"spearman\")\n",
    "spell_err_count = features['spell_err_count'].corr(scores,method=\"spearman\")\n",
    "noun_count =  features['noun_count'].corr(scores,method=\"spearman\")\n",
    "adj_count = features['adj_count'].corr(scores,method=\"spearman\")\n",
    "verb_count = features['verb_count'].corr(scores,method=\"spearman\")\n",
    "adv_count = features['adv_count'].corr(scores,method=\"spearman\")\n",
    "conj_count =  features[\"conj\"].corr(scores,method=\"spearman\")\n",
    "ps_conj_count = features[\"ps_conj\"].corr(scores,method=\"spearman\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('lemma_count', 0.5900492618967987)\n",
      "('char_count', 0.5610447020419941)\n",
      "('word_count', 0.5162290403183958)\n",
      "('adj_count', 0.4643060472605979)\n",
      "('noun_count', 0.4531868654788258)\n",
      "('ps_conj_count', 0.42338742019373443)\n",
      "('adv_count', 0.42173414625123656)\n",
      "('verb_count', 0.4101569091689511)\n",
      "('conj_count', 0.35465992148936676)\n",
      "('sent_count', 0.26635519193646884)\n",
      "('avg_word_len', 0.2290709317896946)\n",
      "('spell_err_count', 0.10274870757647674)\n"
     ]
    }
   ],
   "source": [
    "# 封装成字典并按照value 排序\n",
    "spearman_dic = {\n",
    "    \"char_count\":char_count\n",
    "    ,\"word_count\":word_count\n",
    "    ,\"sent_count\":sent_count\n",
    "    ,\"avg_word_len\":avg_word_len\n",
    "    ,\"lemma_count\":lemma_count\n",
    "    ,\"spell_err_count\":spell_err_count\n",
    "    ,\"noun_count\":noun_count\n",
    "    ,\"adj_count\":adj_count\n",
    "    ,\"verb_count\":verb_count\n",
    "    ,\"adv_count\":adv_count\n",
    "    ,\"conj_count\":conj_count\n",
    "    ,\"ps_conj_count\":ps_conj_count\n",
    "}\n",
    "a = sorted(spearman_dic.items(), key=lambda x: x[1], reverse=True)\n",
    "for item in a:\n",
    "    print(item)\n",
    "# 排序可知,词汇丰富度/作文长度 对作文评分影响最重要，其次是形容词、名词、连词与动词的使用。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "#删除相关度0.3以下的数据\n",
    "processed_features = features.drop([\"avg_word_len\",\"sent_count\",\"essay\",\"id\"],axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>score</th>\n",
       "      <th>char_count</th>\n",
       "      <th>word_count</th>\n",
       "      <th>lemma_count</th>\n",
       "      <th>spell_err_count</th>\n",
       "      <th>noun_count</th>\n",
       "      <th>adj_count</th>\n",
       "      <th>verb_count</th>\n",
       "      <th>adv_count</th>\n",
       "      <th>conj</th>\n",
       "      <th>ps_conj</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>19.5</td>\n",
       "      <td>513</td>\n",
       "      <td>119</td>\n",
       "      <td>88</td>\n",
       "      <td>5</td>\n",
       "      <td>27</td>\n",
       "      <td>7</td>\n",
       "      <td>26</td>\n",
       "      <td>9</td>\n",
       "      <td>2</td>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>16.5</td>\n",
       "      <td>616</td>\n",
       "      <td>137</td>\n",
       "      <td>88</td>\n",
       "      <td>6</td>\n",
       "      <td>28</td>\n",
       "      <td>11</td>\n",
       "      <td>27</td>\n",
       "      <td>9</td>\n",
       "      <td>4</td>\n",
       "      <td>14</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>20.5</td>\n",
       "      <td>676</td>\n",
       "      <td>164</td>\n",
       "      <td>93</td>\n",
       "      <td>4</td>\n",
       "      <td>30</td>\n",
       "      <td>15</td>\n",
       "      <td>33</td>\n",
       "      <td>11</td>\n",
       "      <td>7</td>\n",
       "      <td>15</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>15.5</td>\n",
       "      <td>555</td>\n",
       "      <td>130</td>\n",
       "      <td>79</td>\n",
       "      <td>7</td>\n",
       "      <td>26</td>\n",
       "      <td>10</td>\n",
       "      <td>23</td>\n",
       "      <td>13</td>\n",
       "      <td>4</td>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>19.0</td>\n",
       "      <td>657</td>\n",
       "      <td>150</td>\n",
       "      <td>89</td>\n",
       "      <td>15</td>\n",
       "      <td>32</td>\n",
       "      <td>10</td>\n",
       "      <td>28</td>\n",
       "      <td>12</td>\n",
       "      <td>6</td>\n",
       "      <td>13</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   score  char_count  word_count  lemma_count  spell_err_count  noun_count  \\\n",
       "0   19.5         513         119           88                5          27   \n",
       "1   16.5         616         137           88                6          28   \n",
       "2   20.5         676         164           93                4          30   \n",
       "3   15.5         555         130           79                7          26   \n",
       "4   19.0         657         150           89               15          32   \n",
       "\n",
       "   adj_count  verb_count  adv_count  conj  ps_conj  \n",
       "0          7          26          9     2        8  \n",
       "1         11          27          9     4       14  \n",
       "2         15          33         11     7       15  \n",
       "3         10          23         13     4        8  \n",
       "4         10          28         12     6       13  "
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "processed_features.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABmgAAAcACAYAAADUqcxbAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOzdd5gd1X0/4M/ZXfVeVgIkEL13A6JXAwYMxCVOXBPXOMbGcbfjuMZO3B1XsOPyc3fixAUXjB2wTe+iCokuUAH13vfO748VixYk0CbaudbqfZ9nH2lmzsz9znPnmb17P3POKVVVBQAAAAAAgPq0NLsAAAAAAACA7Y2ABgAAAAAAoGYCGgAAAAAAgJoJaAAAAAAAAGomoAEAAAAAAKiZgAYAAAAAAKBmAhoAAAAAAIDNKKV8q5Qyt5Ry12a2l1LKF0sp95dS7iilHL4lxxXQAAAAAAAAbN7/S/K8Z9h+VpK9Nvy8IclFW3JQAQ0AAAAAAMBmVFV1ZZKFz9Dk/CTfrTpdn2RkKWXHZztu29YqEAAAAAAA2PpO/vCXq2bX0Jf96SNv+bt09nx5wterqvp6Dw4xIcmjGy3P3LBuzjPtJKABAAAAAAC2WxvCmJ4EMk9VNnXYZ9vJEGcAAAAAAAD/ezOT7LzR8sQks59tJwENAAAAAADA/94lSV5VOh2dZElVVc84vFliiDMAAAAAAIDNKqX8KMnJScaWUmYm+VCSfklSVdXFSX6T5Owk9ydZmeTVW3JcAQ0AAAAAAMBmVFX10mfZXiW5oKfHNcQZAAAAAABAzQQ0AAAAAAAANRPQAAAAAAAA1ExAAwAAAAAAULO2ZhcAAAAAAABsXiml2SXQC/SgAQAAAAAAqJmABgAAAAAAoGYCGgAAAAAAgJoJaAAAAAAAAGomoAEAAAAAAKiZgAYAAAAAAKBmAhoAAAAAAICaCWgAAAAAAABq1tbsAgAAAAAAgM1rKaXZJdAL9KABAAAAAAComYAGAAAAAACgZgIaAAAAAACAmgloAAAAAAAAaiagAQAAAAAAqJmABgAAAAAAoGYCGgAAAAAAgJoJaAAAAAAAAGrW1uwCAAAAAACAzSul2RXQG/SgAQAAAAAAqJmABgAAAAAAoGYCGgAAAAAAgJoJaAAAAAAAAGomoAEAAAAAAKiZgAYAAAAAAKBmAhoAAAAAAICatTW7AAAAAAAAYPNaW/S16Iu8qwAAAAAAADUT0AAAAAAAANRMQAMAAAAAAFAzAQ0AAAAAAEDNBDQAAAAAAAA1E9AAAAAAAADUTEADAAAAAABQMwENAAAAAABAzdqaXQAAAAAAALB5pZRml0Av0IMGAAAAAACgZgIaAAAAAACAmgloAAAAAAAAaiagAQAAAAAAqJmABgAAAAAAoGYCGgAAAAAAgJoJaAAAAAAAAGomoAEAAAAAAKhZW7MLAAAAAAAANq+lNLsCeoMeNAAAAAAAADUT0AAAAAAAANRMQAMAAAAAAFAzAQ0AAAAAAEDNBDQAAAAAAAA1E9AAAAAAAADUTEADAAAAAABQMwENAAAAAABAzdqaXQAAAAAAALB5LUVfi77IuwoAAAAAAFAzAQ0AAAAAAEDNBDQAAAAAAAA1E9AAAAAAAADUTEADAAAAAABQMwENAAAAAABAzQQ0AAAAAAAANRPQAAAAAAAA1Kyt2QUAAAAAAACb11JKs0ugF+hBAwAAAAAAUDMBDQAAAAAAQM0ENAAAAAAAADUT0AAAAAAAANRMQAMAAAAAAFAzAQ0AAAAAAEDNBDQAAAAAAAA1E9AAAAAAAADUrK3ZBQAAAAAAAJtXSrMroDfoQQMAAAAAAFAzAQ0AAAAAAEDNBDQAAAAAAAA1E9AAAAAAAADUTEADAAAAAABQMwENAAAAAABAzQQ0AAAAAAAANRPQAAAAAAAA1Kyt2QUAAAAAAACb11JKs0ugF+hBAwAAAAAAUDMBDQAAAAAAQM0ENAAAAAAAADUT0AAAAAAAANRMQAMAAAAAAFAzAQ0AAAAAAEDNBDQAAAAAAAA1a2t2AQAAAAAAwOa1tOhr0Rd5VwEAAAAAAGomoAEAAAAAAKiZgAYAAAAAAKBmAhoAAAAAAICaCWgAAAAAAABqJqABAAAAAAComYAGAAAAAACgZgIaAAAAAACAmrU1uwAAAAAAAGDzWkqzK6A36EEDAAAAAABQMwENAAAAAABAzQQ0AAAAAAAANRPQAAAAAAAA1ExAAwAAAAAAUDMBDQAAAAAAQM0ENAAAAAAAADUT0AAAAAAAANSsrdkFAAAAAAAAm1dKaXYJ9AI9aAAAAAAAAGomoAEAAAAAAKiZgAYAAAAAAKBmAhoAAAAAAICaCWgAAAAAAABqJqABAAAAAAComYAGAAAAAACgZgIaAAAAAACAmrU1uwAAAAAAAGDzWou+Fn2RdxUAAAAAAKBmAhoAAAAAAICaCWgAAAAAAABqJqABAAAAAAComYAGAAAAAACgZgIaAAAAAACAmgloAAAAAAAAaiagAQAAAAAAqFlbswsAAAAAAAA2r5RmV0Bv0IMGAAAAAACgZgIaAAAAAACAmgloAAAAAAAAaiagAQAAAAAAqJmABgAAAAAAoGYCGgAAAAAAgJoJaAAAAAAAAGomoAEAAAAAAKhZW7MLAAAAAAAANq+llGaXQC/QgwYAAAAAAKBmAhoAAAAAAICaCWgAAAAAAABqJqABAAAAAAComYAGAAAAAACgZgIaAAAAAACAmgloAAAAAAAAaiagAQAAAAAAqFlbswsAAAAAAAA2r5TS7BLoBXrQAAAAAAAA1ExAAwAAAAAAUDMBDQAAAAAAQM0ENAAAAAAAADUT0AAAAAAAANRMQAMAAAAAAFAzAQ0AAAAAAEDNBDQAAAAAAAA1a2t2AQAAAAAAwOa1tpRml0Av0IMGAAAAAACgZgIaAAAAAACAmgloAAAAAAAAaiagAQAAAAAAqJmABgAAAAAAoGYCGgAAAAAAgJoJaAAAAAAAAGrW1uwCAAAAAACAzSulNLsEeoEeNAAAAAAAADUT0AAAAAAAANRMQAMAAAAAAFAzAQ0AAAAAAEDNBDQAAAAAAAA1E9AAAAAAAADUTEADAAAAAABQMwENAAAAAABAzdqaXQAAAAAAALB5LaU0uwR6gR40AAAAAAAANRPQAAAAAAAA1ExAAwAAAAAAUDMBDQAAAAAAQM3a6niRkz/85aqO16FvaG2RG9IzI4cManYJbGM+uePaZpfANua7rTs3uwS2MXvvMLbZJbCNuXr6w80ugW3IBWcc2+wS2MZMbF3f7BLYxlw1Z2mzS2AbdN5RB5vFHnrIN+EAAAAAAAA1E9AAAAAAAADUTEADAAAAAABQs1rmoAEAAAAAAP53WoopfvoiPWgAAAAAAABqJqABAAAAAAComYAGAAAAAACgZgIaAAAAAACAmgloAAAAAAAAaiagAQAAAAAAqJmABgAAAAAAoGYCGgAAAAAAgJq1NbsAAAAAAABg81pKaXYJ9AI9aAAAAAAAAGomoAEAAAAAAKiZgAYAAAAAAKBmAhoAAAAAAICaCWgAAAAAAABqJqABAAAAAAComYAGAAAAAACgZgIaAAAAAACAmrU1uwAAAAAAAGDzSinNLoFeoAcNAAAAAABAzQQ0AAAAAAAANRPQAAAAAAAA1ExAAwAAAAAAUDMBDQAAAAAAQM0ENAAAAAAAADUT0AAAAAAAANRMQAMAAAAAAFCztmYXAAAAAAAAbF4ppdkl0Av0oAEAAAAAAKiZgAYAAAAAAOAZlFKeV0qZXkq5v5Ty3k1sH1VK+Vkp5Y5Syo2llAOf7ZgCGgAAAAAAgM0opbQm+UqSs5Lsn+SlpZT9n9LsH5PcVlXVwUleleQLz3ZcAQ0AAAAAAMDmHZXk/qqqHqyqam2SHyc5/ylt9k9yeZJUVTUtya6llPHPdFABDQAAAAAAwOZNSPLoRsszN6zb2O1JXpgkpZSjkkxKMvGZDiqgAQAAAAAAtlullDeUUm7e6OcNT22yid2qpyx/IsmoUsptSd6SZEqS9c/0um3/24IBAAAAAAC2dVVVfT3J15+hycwkO2+0PDHJ7KccY2mSVydJKaUkeWjDz2bpQQMAAAAAALB5NyXZq5SyWymlf5K/TnLJxg1KKSM3bEuS1yW5ckNos1l60AAAAAAAwJ+x1pZNjbBFXaqqWl9KeXOSy5K0JvlWVVV3l1LeuGH7xUn2S/LdUkpHkqlJXvtsxxXQAAAAAAAAPIOqqn6T5DdPWXfxRv+/LslePTmmIc4AAAAAAABqJqABAAAAAAComYAGAAAAAACgZgIaAAAAAACAmgloAAAAAAAAaiagAQAAAAAAqJmABgAAAAAAoGZtzS4AAAAAAADYvJZSml0CvUAPGgAAAAAAgJoJaAAAAAAAAGomoAEAAAAAAKiZgAYAAAAAAKBmAhoAAAAAAICaCWgAAAAAAABqJqABAAAAAACoWVuzCwAAAAAAADavlNLsEugFetAAAAAAAADUTEADAAAAAABQMwENAAAAAABAzQQ0AAAAAAAANRPQAAAAAAAA1ExAAwAAAAAAUDMBDQAAAAAAQM0ENAAAAAAAADVra3YBAAAAAADA5rW2lGaXQC8Q0PSCd59/ao7Ze9csXrEqr/7qjzbZ5i1nnZCj95qU1evW5xM/vzz3zZmXJDlqz13y5uedkNaWkl/fOjU/vPrWOkuniY7cY+dccObxaWlpyW+mTM2Pr5nSbfvQgQPyrvNOyU6jRmTt+vX59CV/yMPzFiZJXnjUwTn78P1SUvLrKVPz0xvuaMYpULNDd52Q15wyOS2l5PK77s3Pbryz2/YhA/rngjOPzw4jh2Xt+o585bKr8+iCxUmSi1734qxauz6NqpGORpX3/OCXTTgD6nTz/Q/l67/9YxqNRs44/KC85PijNtnu3lmP5R3f/FHe8+Jzcvz+e/doX/qWPXcYm7MP2z+llNz64KO5atqD3bYP6NeWF08+JCOGDEpLKblm+kOZ8tDMJMnbnn9y1q7rSKOq0qiqfO331zTjFKjZ/Xfdkcv+43upGo0cdvzJOe6sc7ttv/ayX+euG65NkjQaHZk/Z3be8bmvZsWyZfnp17/c1W7R/Lk5+bwXZfJzn1dr/dRv/4k75CXHHtp5D5n2UC67fVq37YP798urTjoyY4cPzfqOjnz3Tzdl9qKlW7QvfdOUm27Mty/+ShodjZx21tl5wV+99Glt7rr9tvy/i7+a9evXZ/iIEfnoZz6fJFmxfHku+vxn8sjDD6eUkje9/Z3ZZ/8D6j4FanbdjTfl81+9OI1GR84766y86qV/1W37Lbfdnnd/8MPZaccdkiQnH39cXvvKVyRJli1fnn/57Ofz4MMPJ6Xkn9759hy0//51nwI1m3bHlFzyvW+n0WjkqJNPy6nnvqDb9j/++he59dqrkiSNjkbmzp6ZD3/1mxk8dFjnukZHvvDB92bEqNF5zTveV3v9wLZHQNMLfnvbtPzsxjvzjy947ia3T95rUiaOHpmXf/H72X/i+LztnJPypm/8V1pKyVvPPinv/N4vMm/p8lz8+pfkmukPZca8RTWfAXVrKSUXnnVi3v39X2be0uX56utenOumP5wZ85987192/OG5/7H5+dB//jY7jxmZC88+Me/63iXZtX10zj58v1zwjf/Ouo6OfOLlz88N983IrIVLmnhG9LaWUvL6047OR//rsixYtjKffPm5uen+RzJzo/f9RZMPzkPzFuZTl1yRCaNH5HWnHp2P/NdlXds/9JNLs2zVmmaUT806Go1c9Jsr8rFXvihjhw/L2/79Bzl6nz2yS/uYp7X79v9clcP3mNTjfelbSkme/5wD8p0/3pilq1bn704/LtNmz828pcu72kzec1LmLl2eH1x9SwYP6J8Lzzoxd8yYlY5GlST59h+uz8q165p1CtSs0Wjktz/8Tl7+tvdk+KjR+ca/fDB7H3J42nea0NXm2DPPybFnnpMkuff2W3PD//w2g4YMzaAhQ/OGD3686zj/9u4Ls89hRzTlPKhPKSUvPf7wfOHXf8qiFavyvhc8N3fMmJ05i5d2tXneYfvl0QWLc/Hvr834EcPy0uMPz7/9+k9btC99T0dHR77xlS/mg//6qYwe2573vuVNOeLoY7LzpF272qxYvjzf+PIX8v6PfyLt48ZnyeIn/5761kVfzqFHHJl3fuDDWbduXdau8Tm4r+vo6MhnvvSVfPGT/5px7WPz6gvekhOOPTq7TZrUrd2hBx2Yz378n5+2/+e/clGOPvKI/OuHPpB169ZltWumz2s0OvKz73wzb3jPBzJi9Oh88YPvywGHH5HxE3buanPyOefn5HPOT5JMvfXmXPnbX3WFM0ly1WW/ybidJmTNqlW11w9sm7Z4DppSyoAtWUdyx4zZWbZq9Wa3H7fPbl1PeE2d+XiGDhyQ0UMHZ98J4zNr4ZLMWbQ06zsaueKu+3LcPrvXVTZNtO+EcZm1aEnmLF6a9Y1G/nD3/Tl2n926tZnUPrrryeRHFyzODiOGZdSQQdll7KjcM/PxrFm/Po2qyh0zZuf4fXfb1MvQh+y5w9g8tnhZHl+yPOsbjVw9/cEcuecu3dpMHDMydz4yO0kya+GSjBsxNCMGD2xGuTTZvbMey06jR2bHUSPTr7U1Jx6wb66f9sDT2v3yxtty3H57ZcSQwT3el75l4uiRWbhsZRatWJWORpU7H5mTfSeM79amSmcvmiTp39aaVWvXpbEhnGH7M/uhBzJq3PiMah+X1ra2HHDk0Zl++y2bbX/XTdfngKOOedr6h+65O6Pax2XkmLG9WS5/BnZtH525S5Zn/rIV6Wg0ctMDj+TgXXfq1mbHUcMzbdbcJMnjS5ZlzLAhGTZowBbtS99z//Rp2WGnCRm/407p169fjjv5lNx03bXd2lz1h8sz+bgT0j6u83fWiJGjkiQrV6zIPXfemdOed3aSpF+/fhkydGi9J0Dtpk6fnok77ZQJO+2Yfv365fSTT86V11y3RfuuWLEiU+68M+ed1dmbs1+/fhnmmunzHnng/owdv0PGjBuftrZ+OfTo43L3LTdvtv2U66/OYccc37W8eOGCTLvt1kw+6bQ6ygX6iC0OaJJs6rfYlv1mo5v24UO7PYE6b+nytA8fmvbhQzJv6bKnrB/SjBKp2dhhQzJvSfdrYuyw7u/9g4/Pzwn7dQZ2++w0LuNHDsvY4UPz8LyFOXjSThk+aEAGtLVl8l6T0j7cB8e+bvTQwZm/bEXX8sJlKzNmaPdr5uF5C3P0np1Ph+25w9i0Dx/a1aZK8sEXnZlPveLcnH7Q3rXVTXMsWLY8Y4c/+VTX2OFDs2DZsm5t5i9dluum3Zezjji4x/vS9wwbNDBLNnrYZOnKVRk+qPtzOTfc93Dahw3Nu847NReceUIunTI1XfFMlbzq5KPyxtOPy3N23zn0fUsXL8rw0aO7loePHJ1lizbdC3zdmjV54K47st/hRz5t2903XZ8Dj3x6cEPfM2rIoCxasbJrefGKVRk1ZFC3NjMXLMlhu3X2wtq1fXRGDx2cUUMGb9G+9D0LF8zP2Pb2ruUxY9uzcP78bm3mzJyZ5cuX5YPvenvefcEb88ff/y5J8vhjczJ8xIh85bOfyjvf9He56POfyerVnm7v6+bNX5Bx4568Zsa1j828BfOf1u7OqffkFW94Y/7hfe/vHM4syaw5j2XUiBH5509/Nq/6uzfl45/9fFY9w4O49A1LFy3MyNFPjhQwYvToLFm0YJNt165Zk+l33JaDjpzcte6S73875/z1K1JaevJ1K7C9e9Y7Rillh1LKc5IMKqUcVko5fMPPyUkGP8N+byil3FxKuXn2LcYdfzZVteknTjezmj7n6ZN8Ven+5v/o6lszdOCAfO0NL8kLjjoo982Zn45GI4/MX5QfXzMln3rFefnEy5+fBx5b0DW8DH1XKc9+zfzsxjszZOCAfOaV5+Xsw/bLQ3MXpKNqJEne/6Nf513fvyQf++/f53mH7pf9n/JkPH3Lpn+XdL+Gvn7ZH/Pq556Q1qf8MbEl+9L3bOodfuqlsOcO7ZmzeGk+fckVueh3V+ecww/IgLbOHjXfuPy6XPy7a/K9K2/K5L0mZVL7qF6vmSbbxM1iU7+rkuTeO6Zk5z33yqAh3R8o6Vi/Pvfefmv2O8I8V9urp15Gl912TwYP6J/3v/D0nHzgnnl0/uJ0NBpbtC99z6be46feZzo6OvLgffflH//54/mnf/lk/uuH38/smY92rr//vpzx/PPyma9+LQMGDszP/uPHNVVOs2z6e5bu18y+e+2Zn//we/n+1y/OS/7i/Lz7Qx9J0nktTb/v/rzw3Ofnu1/7agYNHJjv/vg/aqiaZtqS+8wTpk65ObvutW/X8GZTp9ySocNHZOJue/RmiUAftCVz0JyZ5G+TTEzyuY3WL0vyj5vbqaqqryf5epKc/OEv+7i8kSd6zDyhffjQzF+2Im2trWnf6CnlJ9bT981ftjztI7pfEwuWrezWZuXadfn0JX/oWv7Bha/IYxsmSb30tnty6W33JElee+rkbj206JsWLFvRrZfV6GGDs3B592tm1dp1+cplV3ctX/S6F2fuhp5ai1Z0PjG4dNXq3HD/jOy5Y3umznq8hspphrHDh2b+Rj005y9dnjHDun8xev/sx/PJ//pNks7eEjff91BaW1q2aF/6nqWrVmfEoCeHRBw+eNDT5qw6fLeJueqezuHuFi5fmUUrVmbs8CGZtXBJlq3ubLtizdrcM/PxTBw90px6fdzwUaOzdOHCruWlixdm6MiRm2x7903X54BN9JK5/67bs+Muu2bo8BG9VSZ/RhatWJVRGw2pOXLIoCxe2b1Hw+p16/PdP93Utfzxl56TBctWpH9b27PuS98zZuzYzJ83r2t5wfx5GTWm+5x4Y9rbM2zEiAwcOCgDBw7K/gcdlIcffDD7HXhQxrS3Z+9990uSHH38ifn5fwpo+rpx7WMzd+6T18zcefPT/pRrZsiQJ/+mOnbyUfnUF7+cxUuWZFz72LS3t+fA/fZNkpx64vH57o/+s57CaZoRo0dn8cIne8wsWbgww0eO3mTb266/Jocdc1zX8sP3TsvUW2/OtNunZN26tVmzalV+eNEX87K/v7DX6wa2bc/ag6aqqu9UVXVKkr+tquqUjX7Oq6rqpzXU2OdcO/2hnHlI5y/5/SeOz4o1a7Nw+cpMn/14Jo4ZkR1GDktba0tOPXCvXDv9oSZXSx2mzZqbCaM3vPctLTnlgD1z7b3d3/shA/qnbcOT7Wcftl/umDGna/LlkYM7h3QYN3xojt9391xx1/31ngC1u/+x+dlx5PCMGz40bS0tOX6f3XPzA492azN4o2vmuQftnakzH8+qtesyoK0tAzfMGzGgrS2H7Dohj8z3xWlftveEHTJrweI8tmhJ1nV05Mq7p2XyU+Y4+9ZbX5dv/0Pnz3H775U3nXNajtl3zy3al75n1sIlGT1sSEYOGZTWlpKDdtkx054S4i5euSq7j++cJ2TIgP4ZO2xoFi1fmX6trenf1pok6dfamj12GJvHlxgWr6/badfds3DuY1k0f2461q/P3Tddn70POfxp7VavXJkZ907LPoc+fdtdN163yXlp6JtmzFuYcSOGZsywIWltacmRe+ySO2bM7tZmUP9+XT07j99399w3Z15Wr1u/RfvS9+y5z76ZM2tWHn9sTtatW5dr/viHHHn0sd3aHHnMsbnnrjvT0dGRNatX575p0zJxl10yavTojBnbnlmPdn5evvO2KZm4y6RNvQx9yH777JNHZ83K7DmPZd26dfn9H/+YE449ulubBQsXdvW0uXvatFSNRkYMH54xo0dnfPvYzNhwzdx0623ZbdIuT3sN+padd98z8x+bk4VzH8/69ety2/XXZP/Dj3hau1UrV+TBaVNzwEbDtZ79Vy/PP33xa/nHz381r7jgbdlz/wOFM8AW2ZIeNE/4VSnlZUl23Xi/qqo+urWL2tZ94EVn5NBdJ2TE4IH5ydv/Nt/+ww1pa+38w+KSm+/O9ffNyOS9JuUHF74ya9atzyd/cXmSpKNR5Qu/uTKffuX5aSkll06ZmofnLXyml6KPaFRVvnTpVfnky8/tfO9vm5YZ8xbl+c85IEnyq1vuzqT2UXnP+aelUVWZMW9RPvPLJ3vTfPglZ2b4oIFZ39HIFy+9MstXr9ncS9FHNKoq37ji+nzgRWekpaXkirvuy6MLFueMg/dJkvzujumZOHpELjzrxDSqRh5dsCRf3dCbZuSQgXn3eZ2TFra2lFw17cHc9vCspp0Lva+1pSV/f/Yp+cD3/zuNqsrphx6YSePG5jc3354kOfuIQ3q8L31bo6ry61vvzqtOOiotJbn1wZmZt3R5jtij84uJmx94JH+6+/68YPLBueDME5KS/O6OaVm5dl1GDRmUlx7/nCRJSym5Y8bs3P/Y08d7p29paW3N8176qvzw3z6dqtHIIcedmHE7Tcwtf+r8nPucDZPlTr/t5uy+/4HpP2Bgt/3XrVmTh+65O+e84jW1105zNKoq/3HNrbnwrBPT0lJy7fSHMmfR0pywX+fQMFfd80B2GDk8rz7lqDSqKnMWLc33NvSm2dy+9G2tra153QVvycf+8T1pNBo59YyzsvOuu+ayX/0ySXLm88/NxF0m5bAjjsw73vi6lNKS0553dnbZdbckyWsveEu+8Ml/yfr16zJ+hx1zwTve3czToQZtra1551suyFvf+49pNBp5/vPOyO677pqf/vJXSZIXnvv8XHHlVfnpL3+V1tbWDOg/IP/8T+/rGtLqHW++IB/6109m3br1mbDjDvmnd72jmadDDVpbW/MXr3pt/v3TH0+j0chRJ56SHSbunOsu75zP6pjTzkiS3HXzjdn7wEPSf+DAZzocwBYpm5v75GkNS/ltkiVJbknS8cT6qqo++2z7GuKMnnjq/AfwbEaaFJYe+uSOa5tdAtuY77aa6J6e2XsHQSY9c/X0h5tdAtuQC8449tkbwUYmtq5vdglsY66aI/im58476mATlvaid3zn575j70Wf/Zu/aMr125MeNBOrqnper1UCAAAAAACwnehJV4VrSykH9VolAAAAAAAA24me9KA5PsnfllIeSrImSUlSVVV1cK9UBgAAAAAA0Ef1JKA5q9eqAAAAAAAA2I70JKAxCREAAAAAAMBW0JOA5tfpDGlKkoFJdksyPckBvVAXAAAAAABAn7XFAU1VVQdtvFxKOTzJ3231igAAAAAAAPq4lv/tjlVV3ZrkyK1YCwAAAAAAwHZhi3vQlFLevtFiS5LDk8zb6hUBAAAAAABdWkppdgn0gp7MQTNso/+vT+ecNP+9dcsBAAAAAADo+3oyB81HkqSUMqxzsVrea1UBAAAAAAD0YVs8B00p5cBSypQkdyW5u5RySynlwN4rDQAAAAAAoG/a4oAmydeTvL2qqklVVU1K8o4N6wAAAAAAAOiBngQ0Q6qq+sMTC1VV/THJkK1eEQAAAAAAQB+3xXPQJHmwlPKBJN/bsPyKJA9t/ZIAAAAAAAD6tp70oHlNkvYkP93wMzbJq3ujKAAAAAAAgL5si3vQVFW1KMmFvVgLAAAAAADAdmGLA5pSyu+T/GVVVYs3LI9K8uOqqs7spdoAAAAAAGC7V0qzK6A39GSIs7FPhDNJV4+acVu9IgAAAAAAgD6uJwFNo5SyyxMLpZRJSaqtXxIAAAAAAEDftsVDnCV5f5KrSyl/2rB8YpI3bP2SAAAAAAAA+rYtDmiqqvptKeXwJEcnKUneVlXV/Ce2l1IOqKrq7l6oEQAAAAAAoE/pSQ+abAhkfrWZzd9Lcvj/uSIAAAAAAIA+ridz0DybshWPBQAAAAAA0GdtzYCm2orHAgAAAAAA6LO2ZkADAAAAAADAFtiiOWhKKSXJxKqqHn2GZmu3TkkAAAAAAMATWlv0teiLtuhdraqqSvLzZ2lz9NYoCAAAAAAAoK/rSex2fSnlyF6rBAAAAAAAYDuxRUOcbXBKkr8rpcxIsiJJSWfnmoN7pTIAAAAAAIA+qicBzVm9VgUAAAAAAMB2ZIsDmqqqZiRJKWVckoG9VhEAAAAAAEAft8Vz0JRSziul3JfkoSR/SvJwkkt7qS4AAAAAAIA+a4sDmiT/nOToJPdWVbVbktOSXNMrVQEAAAAAAPRhPQlo1lVVtSBJSymlpaqqPyQ5tHfKAgAAAAAA6Lu2eA6aJItLKUOTXJnkB6WUuUnW905ZAAAAAABAkpRSml0CvaAnPWjOT7IqyduS/DbJA0nO7Y2iAAAAAAAA+rIt7kFTVdWKjRa/0wu1AAAAAAAAbBe2uAdNKeWFpZT7SilLSilLSynLSilLe7M4AAAAAACAvqgnc9B8Ksm5VVXd01vFAAAAAAAAbA96MgfN48IZAAAAAACA/7tn7UFTSnnhhv/eXEr5jyQ/T7Lmie1VVf20d0oDAAAAAADom7ZkiLNzN/xbJVmZ5IyNtlVJBDQAAAAAAAA98KwBTVVVr06SUsp3kry1qqrFG5ZHJflsr1YHAAAAAADQB21JD5onHPxEOJMkVVUtKqUctvVLAgAAAAAAnlBKsyugN7T0pO2GXjNJklLK6PQs4AEAAAAAACA9C1g+m+TaUsp/pXPumZck+XivVAUAAAAAANCHbXFAU1XVd0spNyc5NUlJ8sKqqqb2WmUAAAAAAAB9VI+GKNsQyAhlAAAAAAAA/g96MgcNAAAAAAAAW4GABgAAAAAAoGYCGgAAAAAAgJr1aA4aAAAAAACgXq0t+lr0Rd5VAAAAAACAmgloAAAAAAAAaiagAQAAAAAAqJmABgAAAAAAoGYCGgAAAAAAgJoJaAAAAAAAAGomoAEAAAAAAKiZgAYAAAAAAKBmbc0uAAAAAAAA2LyWlGaXQC/QgwYAAAAAAKBmAhoAAAAAAICaCWgAAAAAAABqVsscNK0tciC2XEej0ewS2Ma0thiDk56p1q1pdglsYwYONG0fPdNS/G6iZ1avW9fsEtiG9G9tbXYJbGNKP9/LAMCfI7+hAQAAAAAAaiagAQAAAAAAqJmABgAAAAAAoGYCGgAAAAAAgJqZ8RYAAAAAAP6MldLsCugNetAAAAAAAADUTEADAAAAAABQMwENAAAAAABAzQQ0AAAAAAAANRPQAAAAAAAA1ExAAwAAAAAAUDMBDQAAAAAAQM0ENAAAAAAAADVra3YBAAAAAADA5pVSml0CvUAPGgAAAAAAgJoJaAAAAAAAAGomoAEAAAAAAKiZgAYAAAAAAKBmAhoAAAAAAICaCWgAAAAAAABqJqABAAAAAAComYAGAAAAAACgZm3NLgAAAAAAANi81pbS7BLoBXrQAAAAAAAA1ExAAwAAAAAAUDMBDQAAAAAAQM0ENAAAAAAAADUT0AAAAAAAANRMQAMAAAAAAFAzAQ0AAAAAAEDNBDQAAAAAAAA1a2t2AQAAAAAAwOaVUppdAr1ADxoAAAAAAICaCWgAAAAAAABqJqABAAAAAAComYAGAAAAAACgZgIaAAAAAACAmgloAAAAAAAAaiagAQAAAAAAqJmABgAAAAAAoGZtzS4AAAAAAADYvJZSml0CvUAPGgAAAAAAgJoJaAAAAAAAAGomoAEAAAAAAKiZgAYAAAAAAKBmAhoAAAAAAICaCWgAAAAAAABqJqABAAAAAAComYAGAAAAAACgZm3NLgAAAAAAANi81pbS7BLoBXrQAAAAAAAA1ExAAwAAAAAAUDMBDQAAAAAAQM0ENAAAAAAAADUT0AAAAAAAANRMQAMAAAAAAFAzAQ0AAAAAAEDN2ppdAAAAAAAAsHmllGaXQC/QgwYAAAAAAKBmAhoAAAAAAICaCWgAAAAAAABqJqABAAAAAAComYAGAAAAAACgZgIaAAAAAACAmgloAAAAAAAAatbW7AL6qiP32DkXnHl8Wlpa8pspU/Pja6Z02z504IC867xTstOoEVm7fn0+fckf8vC8hUmSFx51cM4+fL+UlPx6ytT89IY7mnEK1Ojd55+aY/beNYtXrMqrv/qjTbZ5y1kn5Oi9JmX1uvX5xM8vz31z5iVJjtpzl7z5eSektaXk17dOzQ+vvrXO0mmiQyZNyKtPPiotLSWX33VffnHTnd22DxnQP39/xnEZP2JY1nV05KLfXZNHFyxOknz5NS/O6nXr0mhU6agaed8Pf9WEM6BOtzwwI1///dVpVI2cccj++ctjn9Nt+/X3Ppjv/+nGlJK0trTk9acfnwN23ilJ8osbb89lt01NUuXMQw/I+Ucd0oQzoG67jx+T0w/eN6WU3P7wzFx378Pdtg9oa8t5Rx6U4YMGpqWl5Ib7Hs4dM2antaUlrzzxyLS2tKSlpWTarMdz1T0PNOckqNX9d92e3/74e2k0Gjn8hJNz/Fnnddt+zWW/yp3XX5skaTQamT9nVt71+YuyYtnS/NfXvtzVbtH8uTnl/Bfn6Oc+r9b6qd9Bu+yYlx1/RFpaSq6cen9+fevUbtsHD+if1556dMYNH5p1HR355hXXZ9bCJenX2pL3veD0tLW2prWl5KYHHsnPb7xzM69CX3LLjTfkG1/9cjoaHTnjrHPy4pe+/Glt7rxtSr5x0Zezfn1Hho8YkX/93BeSJK97+V9l0KDBaWltSWtraz731a/XXT5NcN0NN+ZzX/pyGo2OnHfOOfmbl7+s2/ZbptyWd73/n7LTjjskSU4+4YS87m//JjMeeSTv/8hHu9rNmj0nb3jNq/PSv3xxrfVTv2l3TMkl3/t2Go1Gjjr5tJx67gu6bf/jr3+RW6+9KknS6Ghk7uyZ+fBXv5nBQ4d1rmt05AsffG9GjBqd17zjfbXXD2x7BDS9oKWUXHjWiXn393+ZeUuX56uve3Gum/5wZsxf1NXmZccfnvsfm58P/edvs/OYkbnw7BPzru9dkl3bR+fsw/fLBd/476zr6MgnXv783HDfjMxauKSJZ0Rv++1t0/KzG+/MP77guZvcPnmvSZk4emRe/sXvZ/+J4/O2c07Km77xX2kpJW89+6S883u/yLyly3Px61+Sa6Y/lBnzFm3yOPQdpZS89tTJ+dhPf5cFy1bmX1/2/Nz8wCPd7hUvOOrgPDxvYT7zyz9kp1Ej8tpTJ+ef//t3Xds/8pPfZtnqNc0on5p1NBq56LIr87GXnpcxw4fmbd/+SSbvtVt2aR/d1eaQXSdm8l67pZSSh+bOzyd/elkufuPL8/DcBbnstqn53KtfnH6trfngj3+ZI/aclAmjRzbvhOh1JcmZh+yXH119S5auWp1Xn3J07pszL/OXrehq85w9ds78pcvzk+umZHD/fvm7M47PXY/MSUejkR9cdXPWdXSkpZS88qSj8sBj8zN7kc8yfVmj0chvfvidvPJt783wUaPz7x//YPY55Dlp32lCV5vjznx+jjvz+UmS6bffmut//9sMGjI0g4YMzRs/9C9dx/ncu96SfQ87oinnQX1KKXnliUfm05dckYXLV+ZDf/m8THloZmYvWtrV5tznHJBH5i/Kly69MjuOHJ5XnnRkPvWLy7Ouo5FP/uLyrFm3Pq0tJf/4wjNy54zZeeDxBU08I3pbR0dHvvalL+Sjn/xMxrS35x0XvDFHHXtcdpm0a1eb5cuX5eIv/ls+/K+fSvv48Vm8qPvfRR//7OczfMTIegunaTo6OvLpf/tCvvTZT2dce3v+9u/emBOOOza777prt3aHHnxQPveJf+22btIuu+T73/xG13Ge/+K/zMknHF9X6TRJo9GRn33nm3nDez6QEaNH54sffF8OOPyIjJ+wc1ebk885Pyefc36SZOqtN+fK3/6qK5xJkqsu+03G7TQha1atqr1++r6S0uwS6AWGOOsF+04Yl1mLlmTO4qVZ32jkD3ffn2P32a1bm0ntozPloZlJkkcXLM4OI4Zl1JBB2WXsqNwz8/GsWb8+jarKHTNm5/h9d9vUy9CH3DFjdpatWr3Z7cfts1suu31akmTqzMczdOCAjB46OPtOGJ9ZC5dkzqKlWd/RyBV33Zfj9tm9rrJpoj13GJvHFi/L3CXL09Fo5NrpD+XIPXbp1mbi6BG585E5SZLZi5akffjQjBg8sBnl0mT3zp6bHUeNyA6jRqRfa2tO3H+vXH/fQ93aDOrfP6V0fthbvXZ9suH/Mxcsyr4Txmdgv35pbWnJgbvslOumP1j7OVCvnUaPyKIVK7N45ao0qipTZz6WvXYc161NVSX9+3U+69OvrS2r1q5Lo6qSJOs6OpIkLS0lrS3+iNgezHrogYxuH59R7ePS2taWA448OtNuu2Wz7e+68boceNQxT1v/0D13Z3T7uIwcM7Y3y+XPwO7jxuTxJcsyb2nnZ5kb7puRw3bbuVubnUaNyNSZjyVJ5ixemrHDhmT4oM7PMmvWrU/S2euztaUlVb3l0wT3TZ+WHXeakB122in9+vXLCSefmhuuuaZbmysvvzzHHH9C2sePT5KMHDWqGaXyZ2LqPdMyccJOmbDhmjn91FNz5dXXPPuOT3HTrbdm4k47ZccdduiFKvlz8sgD92fs+B0yZtz4tLX1y6FHH5e7b7l5s+2nXH91DjvmyeBu8cIFmXbbrZl80ml1lAv0EVsc0JRS/nJL1pGMHTYk85Ys71qet3R5xg4b0q3Ng4/Pzwn7dX6Rvs9O4zJ+5LCMHT40D89bmIMn7ZThgwZkQFtbJu81Ke3Dh9ZaP39+2ocPzbyl3a+p9uFD0z58SOYtXfaU9UM2dQj6mNFDB2fBRk+yL1i+IqOHDu7WZsb8RZm856QkyR7jx6Z9+NCMHvrE9VHl/S88I5942fNz2kF711U2TbJg2fJuv0vGDhva7fp5wrXTH8wbL/5BPvKfv8pbzzk1SecDBXc9OjtLV67O6nXrcvMDMzJ/o/sRfdOwgQOzdKMHB5atWp1hgwZ0a3PLg49k7LAhufDsk/L65x6T398xrWtbSfLaU4/OP5xzch56fIHeM9uBZYsXZfjoJ3vlDR81OssWb7pH77o1a3L/XXdk/+cc+bRtd9206eCGvmfU0EFZuHxl1/Ki5Sszasigbm0eWbAoz9m9M7TZbdyYjBk2JKM2fN4ppeSjf3VWvviaF+XuR+fkQb1n+rwF8+dl7Lj2ruWx7e1ZsGBetzazZj2a5cuX5x/f/ta87e/fkCt+d9mTG0vJB9/zrrzt79+Q3/7ql3WVTRPNnT8/48c9+YDJuPb2zJs//2nt7rx7al7+mtfmH971njz40ENP2/77y6/IGaf5wn17sHTRwowcPaZrecTo0VmyaNO/X9auWZPpd9yWg46c3LXuku9/O+f89StSWjwPD2y5ngxx9r4kP9mCdWyiu1n1lGe6fnT1rbngecfna294SR6auyD3zZmfjkYjj8xflB9fMyWfesV5WbV2XR54bEE6Gp4H4+mqatPXxWZW08ds6nn0p773P7/pzvztyUflUy8/L48sWJSH5i5Mo9FIknzgP36TRStWZfiggfmnF52R2QuX5J5Zj/d+4fzZ2NQ1dOw+u+fYfXbPXY/MzvevvCEff9n52Xns6Lz46MPzgR/9IgP798tu48am1R8cfd8WdHrZfdzYPL54WX5w1c0ZNWRQXnr8EfnG/Guzdn1HqiTfvOL6DOjXlhcffejTHjSg79nc55JNmX7HlOyy594ZNKT7Q0gd69dn+u235rQX/tXWLo8/Q1syRMevb7k7Lz/hiHz0r87KzAVLMmPeoq7PMlVV5YP/cWkG9++Xt5x1YiaMHmFY6D5uU7eZp15HHR0duf/e6fnYpz+XtWvX5F0XXpB99t8/EybunE/+25czZuzYLF60KB98zzszcZddcuDB5tXr0zZx0Tz1mtln773yi//4cQYPHpRrrr8+73r/B/LfP/x+1/Z169blqmuvzZve8PpeL5fm2+R9pmz699XUKTdn17327RrebOqUWzJ0+IhM3G2PPHDP3b1ZJtDHPGtAU0o5K8nZSSaUUr640abhSdY/w35vSPKGJNnn3JdmwhHbz1id85ctT/uIJ//gbB8+NAuWrezWZuXadfn0JX/oWv7Bha/IYxvGW770tnty6W33JElee+pkX2jQ1WPmCe3Dh2b+shVpa21N+/BhT1tP37dg+cqM2ahn3pihQ7JoRff7zKq163LR757swv/l17w4czfcTxat6BwPd+mq1bnp/key5w5jBTR92Jhh3b8cn79seUYP23xvuwN32SmPLVqSJStXZcTgQTnj0P1zxqH7J0m+88frMnaYnp193bJVq7uGEUqSYYMGZtmq7nNWHbzrTrlueudTpotWrMriFasyZtiQzNlo/og169ZnxryF2X38GJ9n+rjho0Zn6cKFXctLFy3MsJGbHlro7s0Mb3bfXbdnx112zdDhI3qtTv58LFy+slvv31FDB3d9PnnC6nXr880rru9a/swrz3/avWTl2nWZNntuDtplJwFNHze2vT3z5z7ZY2b+vHkZ/ZThEMeObc/w4SMycNCgDBw0KAccdEgeeuCBTJi4c8aM7Ww7ctSoHH3c8blv2j0Cmj5uXHt7Hp87t2t57rx5GTt2TLc2Q4c8+Zn4uKOPzqc//29ZvHhJRo7s/F107Q03ZJ+99s6YjXqJ0neNGD06ixc+2WNmycKFGT5y0+/9bddfk8OOOa5r+eF7p2XqrTdn2u1Tsm7d2qxZtSo/vOiLednfX9jrdQPbti15BHZ2kpuTrE5yy0Y/lyQ5c3M7VVX19aqqjqiq6ojtKZxJkmmz5mbC6BHZYeSwtLW05JQD9sy193bvJjtkQP+0bXgC+ezD9ssdM+Zk5dp1SZKRgzu79o8bPjTH77t7rrjr/npPgD87105/KGcesm+SZP+J47NizdosXL4y02c/noljNlxrrS059cC9cu30p3fJpu954LH52XHU8LQPH5rWlpYcu89uufnBR7u1GTygf1dPh9MO3Cv3zHosq9auy4C2tgzcMG/EgLa2HDxppzwyf3Hdp0CN9t5pXGYvWpLHFi/Nuo6OXDn1vkzea9dubWYvXNz1BPz9j83Luo5G1xf0izeEf3OXLMt10x7MSfvvVWv91G/2oqUZNXRwRgwelJZSsv/EHXLfnLnd2ixduTq7juv8kmPIgP4ZM2xwFq9YlcH9+2XAhntMW0tLdhs3ZpND6tG3TNh19yyY+1gWzZubjvXrc/dN12efQw5/WrvVK1fm4XunZZ9Dn75tc/PS0Dc9NHdBxo8YlrHDhqS1pSWT95qUKQ/P7NZmcP9+XZ9lTtp/j0yfPTer163PsIEDMrh/vyRJv9bW7D9xh27hMH3TXvvsk9mzZuaxOXM6ezX88YpMPvbYbm0mH3t8pt51Zzo61mfN6tW5d9rU7LzLLlm9alVWruz8PLN61arcdsvN2WVXc732dfvtu28enTkrszdcM7+/4oqceFz3a2bBgoVdn4HvvueeNBpVRowY3rX9d5dfkTNOO7XWummenXffM/Mfm5OFcx/P+vXrctv112T/w494WrtVK1fkwWlTc8DhTw7XevZfvTz/9MWv5R8//9W84oK3Zc/9DxTOAFvkWXvQVFV1e5LbSyk/rKpqXQ01bfMaVZUvXXpVPvnyc9NSSi69bVpmzFuU5z/ngCTJr265O5PaR+U955+WRlVlxrxF+cwvn+xN8+GXnJnhgwZmfUcjX7z0yixfvWZzL0Uf8YEXnZFDd52QEYMH5idv/9t8+w83pK2184/RS26+O9ffNyOT95qUH1z4yqxZtz6f/MXlSZKORpUv/ObKfPqV53dea1Om5uF5C5/ppegjGlWVb11xfd7/wtPTUkr+cPf9mblgcU4/eJ8kye/vmJ4Jo0fkzWeekEZVZeaCxbn49529aUYMGZh3ntv5R0ZrS8nV0x7K7TNmNe1c6H2tLS154xkn5IM/viSNRpXTD9kvk9rH5De33pUkOfvwA3Pt9AdzxZ3T0trSkv792vKeF5zR1Z3/X/77t1m2anVaW1vyxjNPzNCNelbQN1VVld/dNi1/fdzhaSklt8+YlfnLVuSw3SYmSaY8NDNXT3swz3/OAXndacekpOSKu+7LqrXr0j58aM494sC0lJKSkntmPZb7H3v6eO/0LS2trTn7ZX+T7//bp1JVjRx63EkZN2Fibv5j52eWI07uHLt/2pSbs8cBB6X/gO73kXVr1uTBqXfl+a94Te210xyNqsr3r7o57zzv1LSUkqvueSCzFy7JKQd0PgTwh7vvy46jRuT1zz0mVVVl1sIl+dYfbkiSjBgyKK8/7ZjO+0wpufH+GT7LbAdaW9vyd295az783nel0Wjkuc87K7vsulsu/eUvkiRnnXt+dp40KYcfcVQufP1rU1pKTj/rnEzabfc8Nnt2/uXDH0jSOQzaSaeeluccNfmZXo4+oK2tNe/8hwtz4TvfnUajkXPPPiu777ZbfvqLS5IkLzz/vFzxpz/lv3/xi7S2tmbAgAH52Ic+0PUZePXq1bnx5lvyvne8vZmnQY1aW1vzF696bf790x9Po9HIUSeekh0m7pzrLv9dkuSY085Iktx1843Z+8BD0n+gv4uA/7uypeNFl1KOS/LhJJPSGeyUJFVVVbs/276nffSrZsVgi3VsGFcattS4EYZbomc+PtpTtvTMT4bt2+wS2MbsOnbTw3vB5vzuznubXQLbkPed54l+emZ8P1/L0DNXPuIBG3ruvKMO3oLZLPnf+uwlV7iZ96J3nHdqU67fZ+1Bs5FvJnlbOoc36+idcgAAAAAAAPq+ngQ0S6qqurTXKgEAAAAAAJ6mpeig1Bf1JKD5Qynl00l+mqRrUpSqqm7d6lUBAAAAAAD0YT0JaJ6YQe+IjdZVSQx+CwAAAAAA0ANbHNBUVXVKbxYCAAAAAACwvdjigKaU8sFNra+q6qNbrxwAAAAAAIC+rydDnK3Y6P8Dkzw/yT1btxwAAAAAAIC+rydDnH124+VSymeSXLLVKwIAAAAAAOjjWv4P+w5OsvvWKgQAAAAAAGB70ZM5aO5MUm1YbE3SnsT8MwAAAAAAAD3Ukzlonr/R/9cnebyqqvVbuR4AAAAAAGAjrS2l2SXQC7Z4iLOqqmYkGZnk3CQvSLJ/L9UEAAAAAADQp21xQFNKeWuSHyQZt+HnB6WUt/RWYQAAAAAAAH1VT4Y4e22SyVVVrUiSUsonk1yX5Eu9URgAAAAAAEBftcU9aJKUJB0bLXdsWAcAAAAAAEAP9KQHzbeT3FBK+dmG5b9I8s2tXhEAAAAAAEAft8UBTVVVnyul/DHJ8ensOfPqqqqm9FZhAAAAAAAAfdUWBzSllKOT3F1V1a0bloeVUiZXVXVDr1UHAAAAAADQB/VkDpqLkizfaHnFhnUAAAAAAAD0QE/moClVVVVPLFRV1Sil9GR/AAAAAACgh0opzS6BXtCTHjQPllIuLKX02/Dz1iQP9lZhAAAAAAAAfVVPApo3Jjk2yawkM5NMTvKG3igKAAAAAACgL9viIcqqqpqb5K83t72U8r6qqv51q1QFAAAAAADQh/WkB82z+cuteCwAAAAAAIA+a2sGNGYpAgAAAAAA2AJbM6CptuKxAAAAAAAA+iw9aAAAAAAAAGq2NQOan2zFYwEAAAAAAPRZbc/WoJTypTzD8GVVVV244d9/2Yp1AQAAAAAASUoxgFVftCU9aG5OckuSgUkOT3Lfhp9Dk3T0WmUAAAAAAAB91LP2oKmq6jtJUkr52ySnVFW1bsPyxUl+16vVAQAAAAAA9EE9mYNmpyTDNloeumEdAAAAAAAAPfCsPWg28okkU0opf9iwfFKSD2/1igAAAAAAAPq4LQpoSiktSaYnmbzhJ0neW1XVY71VGAAAAAAAQF+1RQFNVVWNUspnq6o6JskverkmAAAAAACAPq0nc9D8rpTyolJK6bVqAAAAAAAAtgM9CWjenuQnSdaWUpZt+FnaS3UBAAAAAAD8WSilPK+UMr2Ucn8p5b2b2D6ilPLLUsrtpZS7SymvfrZjbtEQZ0lSVdWwnhYMAAAAAAD837S2GNiqmUoprUm+kuT0JDOT3FRKuaSqqqkbNbsgydSqqs4tpbQnmV5K+UFVVWs3d9wtDmg2FHFekhM3LP6xqqpf9egsAAAAAAAAti1HJbm/qqoHk6SU8uMk5yfZOKCpkgzbME3M0CQLk6x/poNu8RBnpZRPJHnrhhecmuStG9YBAAAAAAD0VROSPLrR8swN6zb25ST7JZmd5M4kb62qqvFMB+1JD5qzkxz6xAFLKd9JMiXJ08ZaAwAAAAAA2BaUUt6Q5A0brfp6VVVf37jJJnarnrJ8ZpLbkpyaZI8kvy+lXFVV1dLNvW6PhjhLMjKd3XKSZEQP9wUAAAAAAPizsiGM+fozNJmZZOeNliems6fMxl6d5BNVVVVJ7i+lPJRk3yQ3bu6gPQlo/iXJraWUP6YzLToxyft6sD8AAAAAAMC25qYke5VSdksyK8lfJ3nZU9o8kuS0JFeVUsYn2SfJg8900J4ENOck+VaSRRte6D1VVT3Wg/0BAAAAAAC2KVVVrS+lvDnJZUlak3yrqqq7Sylv3LD94iT/nOT/lVLuTGcnl/dUVTX/mY7bk4Dm20mOT3Jekt2T3FZKubKqqi/0/HQAAAAAAAC2DVVV/SbJb56y7uKN/j87yRk9OeYWBzRVVV1RSvlTkiOTnJLkjUkOSCKgAQAAAACAXtJSNjVHPdu6LQ5oSimXJxmS5LokVyU5sqqqub1VGAAAAAAAQF/V0oO2dyRZm+TAJAcnObCUMqhXqgIAAAAAAOjDejLE2duSpJQyNMmr0zknzQ5JBvROaQAAAAAAAH1TT4Y4e3OSE5I8J8mMJN9K51BnAAAAAAAA9MAWBzRJBiX5XJJbqqpa30v1AAAAAAAA9Hk9GeLs071ZCAAAAAAAwPaipdkFAAAAAAAAbG8ENAAAAAAAADXryRw0AAAAAABAzVpKaXYJ9AI9aAAAAAAAAGomoAEAAAAAAKiZgAYAAAAAAKBmAhoAAAAAAICaCWgAAAAAAABqJqABAAAAAAComYAGAAAAAACgZgIaAAAAAACAmrU1uwAAAAAAAGDzSinNLoFeoAcNAAAAAABAzQQ0AAAAAAAANatliLORQwbV8TL0Ea0tuuvRM3OXLG92CWxrxrY2uwK2Mes7Gs0ugW3MkAH9m10C25hdx45udglsQxpV1ewS2MZ0rFzR7BLYxvRv8zcTQB30oAEAAAAAAKiZgAYAAAAAAKBmAhoAAAAAAICaCWgAAAAAAABqJqABAAAAAACoWVuzCwAAAAAAADavtaU0uwR6gR40AAAAAAAANRPQAAAAAAAA1ExAAwAAAAAAUDMBDQAAAAAAQM0ENAAAAAAAADUT0AAAAAAAANRMQAMAAAAAAFAzAQ0AAAAAAEDN2ppdAAAAAAAAsHmllGaXQC/QgwYAAAAAAKBmAhoAAAAAAICaCWgAAAAAAABqJqABAAAAAAComYAGAAAAAACgZgIaAAAAAACAmgloAAAAAAAAaiagAQAAAAAAqFlbswsAAAAAAAA2r6Q0uwR6gR40AAAAAAAANRPQAAAAAAAA1ExAAwAAAAAAUDMBDQAAAAAAQM0ENAAAAAAAADUT0AAAAAAAANRMQAMAAAAAAFAzAQ0AAAAAAEDN2ppdAAAAAAAAsHmtLaXZJdAL9KABAAAAAAComYAGAAAAAACgZgIaAAAAAACAmgloAAAAAAAAaiagAQAAAAAAqJmABgAAAAAAoGYCGgAAAAAAgJoJaAAAAAAAAGrW1uwCAAAAAACAzWsppdkl0Av0oAEAAAAAAKiZgAYAAAAAAKBmAhoAAAAAAICaCWgAAAAAAABqJqABAAAAAAComYAGAAAAAACgZgIaAAAAAACAmrU1uwAAAAAAAGDzSinNLoFeoAcNAAAAAABAzQQ0AAAAAAAANRPQAAAAAAAA1ExAAwAAAAAAUDMBDQAAAAAAQM0ENAAAAAAAADUT0AAAAAAAANRMQAMAAAAAAFCztmYXAAAAAAAAbF4ppdkl0Av0oAEAAAAAAKiZgAYAAAAAAKBmAhoAAAAAAICaCWgAAAAAAABqJqABAAAAAAComYAGAAAAAACgZm3NLqCvOnTXCXnNKZPTUkouv+ve/OzGO7ttHzKgfy448/jsMHJY1q7vyFcuuzqPLlicJLnodS/OqrXr06ga6WhUec8PftmEM6Buh0yakFeffFRaWkouv+u+/OKmp18zf3/GcRk/YljWdXTkot9d03XNfPk1L87qdevSaFTpqBp53w9/1YQzoE7vPv/UHLP3rlm8YlVe/dUfbbLNW846IUfvNSmr163PJ35+ee6bMy9JctSeu+TNzzshrS0lv751an549a11lk6T3PLAw/n6ZVemUVU549AD8pfHHdFt+/XTH8j3/3R9SilpbWnJ608/MQfsslOS5Bc33pbLptyVVMmZhx2Q8ycf1oxToGZ7jB+bMw/bLy0lmfLgzFwz/aFu2we0teUFkw/O8MED01JKrrv34dz+8KwkyYVnn5Q169enqqo0GlW+cfl1zTgFajb9jtvyi+9/O1WjkaNOOi2nnPsX3bb/8deXZMp1VyVJGh2NzJ09Mx/6yjczeOjQznWNRr74wfdm+KjRec073lt3+TTBnjuMzfMO2y8tpeTWB2fm6mkPdts+oF9bXjj5kIwY0nmfuXb6Q7ntoc77zD88/6SsWdfReZ+pqnz999c24xSo2a033ZhvfPXLaTQ6cvpZ5+RFf/2yp7W58/bb8s2vfjkdHeszfPiIfPxzX0iSvP4Vf51BgwanpaUlra2t+exXv1Z3+TTB9Tffkn+7+OvpaDRy7vPOyKte8pfdtt96xx15z0c+lp12GJ8kOenYY/Oal7+0a3tHR0dec+Hb0j52TD7zkQ/VWjvNcc9tt+an3/1WGo1Gjj7luTn9/Bd22375L3+eW665Mknn9fH4rFn5+Ne/nf79B+SLH/2nrF+3Lo2ORg6ZfEzO/su/bsYpANsYAU0vaCklrz/t6Hz0vy7LgmUr88mXn5ub7n8kMxcu6WrzoskH56F5C/OpS67IhNEj8rpTj85H/uuyru0f+smlWbZqTTPKpwlKKXntqZPzsZ/+LguWrcy/vuz5ufmBRzJro2vmBUcdnIfnLcxnfvmH7DRqRF576uT883//rmv7R37y2yxb7ZrZXvz2tmn52Y135h9f8NxNbp+816RMHD0yL//i97P/xPF52zkn5U3f+K+0lJK3nn1S3vm9X2Te0uW5+PUvyTXTH8qMeYtqPgPq1NFo5KJL/5iPvfwFGTN8aN72zf/I5L13yy7tY7raHLLbzpm89+4ppeShx+fnkz+9NBf//Svz8NwFuWzKXfnca/4q/Vpb88Ef/iJH7LVbJowe2bwToteVJGcdvn++f+VNWbpydV733GMyffbczF+2oqvNkXvuknlLl+fH19yawf375YKzTsidM2anUVVJku/+8casWruuSWdA3RqNRn723W/m9e/+p4wYPSZf+tD7sv/hR2T8hIldbU4+57ycfM55SZKpU27OVb/9dVc4kyRXX/abjNtpQlavWlV7/dSvlOTs5xyQ7/3xxixdtTqvP/3YTJ89N/OWLu9qc9SG+8yPrr4lgwf0z1s23Gc6Gp33me/84YasdJ/ZbnR0dORrX/pCPvLJT2fM2Pa8681vzFHHHJudJ+3a1Wb58uX52hf/LR/610+mfdz4LF7U/TPuxz7z+QwfMaLmymmWjo6OfOYrF+UL//KxjBs7Jq9969tywuTJ2W3SLt3aHXLgAZsNX/7zF5dk1112zoqVK+somSZrNDryk2//e970jx/KyDFj8tn3vzsHPefI7DBx5642p537Fzltw0Mod91yU/74m19myNBhqaoqb/6nj2TAwEHpWL8+X/jw+7P/oYdl1732adLZANsKQ5z1gj13GJvHFi/L40uWZ32jkaunP5gj9+z+AWDimJG585HZSZJZC5dk3IihGTF4YDPK5c/AE9fM3CXL09Fo5NrpD+XIPZ5yzYwekTsfmZMkmb1oSdqHu2a2Z3fMmJ1lq1Zvdvtx++yWy26fliSZOvPxDB04IKOHDs6+E8Zn1sIlmbNoadZ3NHLFXffluH12r6tsmuTe2Y9nx9Ejs8OoEenX2poTD9gr19/b/SnlQf37p5SSJFm97skvu2bOX5h9J+yQgf36pbWlJQdOmpDrpj1Qa/3Ub8LokVm0fGUWr1iVRlXl7kcfyz4TxndrUyXp39b5rE//trasWruuK5xh+/PoA/dn7LgdMmbc+LS1teWQo4/N3bfetNn2t113TQ49+riu5cULF2Ta7bfmqJNPq6Nc/gxMGD0yC5etyKIVq9LRqHLXI3Oyz4Rx3dpUSQb0a02S9G9r7bzPNNxntlf3TZ+WHXfaKTvsuFP69euX408+NTdce023Nlde8T855vgT0j6u83fWyFGjmlEqfyam3ntvJu60YybsuEP69euX5550Yq66/vot3n/uvPm59sabcu6ZZ/Rilfw5mXH//WnfYceMHb9D2tr65fBjjs+dN9+42fa3XHt1Dj/2hCSdD94OGDgoSWc42NGxvvNpBNiKWluKn178aZYtDmhKKcdtyTqS0UMHd3vCdOGylRkzdEi3Ng/PW5ij95yUpPPL+fbhQ7vaVEk++KIz86lXnJvTD9q7trppntFDB2fBRtfMguUrMnro4G5tZsxflMkbrpk9xndeM6O7rqsq73/hGfnEy56f01wzJGkfPrTbE6jzli5P+/ChaR8+JPOWLnvK+iGbOgR9yIJlne//E8YOG9rtnvOEa6c9kDde9L185MeX5K3ndvbOmjRuTO56ZHaWrlyV1evW5eb7H878ja4h+qZhgwZkyconezEsXbk6wwYN6NbmpvtnpH34kLzt+SfnjWcel8umTOvaVqXKK048Iq977jE5fLeJoe9bsmhhRox5slfeiNFjsnTRwk22XbtmTabfeVsOOvLornW//MH/y9l/9YquoJi+b/iggVm60cMmS1euzvBB3R8+uvG+GRk7bGjecd4pedOZx+fSKffkiXimqpJXnnxk3nD6sXnO7juHvm/h/PkZ2/5kiDdmbHsWzp/frc3smTOzfNmyvP8d/5C3v+kN+cPvnxylopSSD7/3XXn7m96Qy35tGPHtwbz5CzK+vb1ruX3s2MxbsOBp7e66Z1pe9aY35+0f+FAenDGja/2/fe3rueC1r0lLE7+0o15LFi3IyI0+z4wcMyZLnuHzzLTbp+SQyU9+nmk0OvKp97497/+7V2efgw7Jrnv6fgZ4dj0Z4uxLSQ7fgnXbvU39YVml+5NeP7vxzrzmlMn5zCvPyyPzF+WhuQvSUTWSJO//0a+zaMWqDB80MB968ZmZtXBJps56vJbaaY5Nfdx76kPIP7/pzvztyUflUy8/L48sWJSH5i5Mo9F5zXzgP37Tdc3804vOyOyFS3KPa4anqDbzZLsH3rcDm3iPN3XfOXbfPXLsvnvkrhmz8v0/Xp+Pv+IF2Xns6Lz4mOfkAz/8eQb265fdxo9Na4sOuH3eJn8xdV/cY3xn78/v/ummjBoyOK846YjM+N3CrF3fkW9fcUOWr16TwQP65xUnHpH5y1bkkfmGUuzbNvXLZNNfaE2dckt23WufruHNpk65JUOHjcjE3XbPA/fc3Ys18ufuqX8z7blDex5bvDTf+eONGT10cF550pG5+LJrsmb9+nzr8uuzbPWaDBnQP688+cjMX7bckK193CY/yz7lb+9GR0ceuO/efPRTn83atWvzngsvyN777Z8JE3fOJz7/pYweOzaLFy3Kh9/7zkzceZcccPAhNVXPn4vylN9N++yxZ376nW9l8KBBufbGm/Lej34s//nNf881N9yYUSNHZt+99sytd9zRpGqpW0/+Nr7r1puy2z77ZsjQYV3rWlpa8+5PfC4rV6zINz/3ycx+dEZ22nlSL1QK9CXPGtCUUo5JcmyS9lLK2zfaNDxJ6zPs94Ykb0iSw178qux29Mn/t0q3IQuWrcjYYU8+kT562OAsXN59vNJVa9flK5dd3bV80etenLlLOp92X7Si84nVpatW54b7Z2TPHdsFNH3cguUrM2aja2bM0CFZtOLp18xFv3uyC/+XX/PizF369GvmpvsfyZ47jBXQbOee6DHzhPbhQzN/2Yq0tbamffiwp62nbxvzlB5V85ctz+hhm+85deCkCXnskiVZsnJVRgwelDMOOyBnHHZAkuQ7V1ybsRtdW/RNy1auyYjBg7qWhw8e+LR5zg7dbUKumfZQkmTRis7h0MYOG5rZi5Zk+Ya2K9eszfRZczNh9AgBTR83YtSYLNnoqeQlCxdk+GaGFrr9hmty6NHHdy3PuG96pk65OdPumJJ169ZmzapV+dHFX8xL33hhr9dN8yxd1b3HzPDBA582B+ehu03I1fd0Dsm5cMOwi2OHD8mshUu67kkr1qzNtJmPZ8LokQKaPm5Me3vmz5vbtbxg/ryM3uhJ9yfaDBsxIgMHDcrAQYOy/8EH5+EHHsiEiTtn9NixSTqHPZt83Am5b/o0AU0f1z52TB6fN69red78+Rk7ZnS3NkOGPDlyxbFHHZnPfOWiLF6yJHdMnZqrr78h1910c9auW5sVK1flw5/6TD787nfWVj/1Gzl6TBZv9Hlm8YIFGTFq9Cbb3nrt1Tn82OM3uW3wkCHZc78DMu32KQIa4FltySOw/ZMMTWeYM2yjn6VJXry5naqq+npVVUdUVXXE9hTOJMn9j83PjiOHZ9zwoWlracnx++yemx94tFubwQP6p23DE8jPPWjvTJ35eFatXZcBbW0Z2K8zNxvQ1pZDdp3gC43twAOPzc+Oo4anffjQtLa05Nh9dsvNDz79mnniqfXTDtwr98x6bJPXzMGTdsoj8xfXfQr8mbl2+kM585B9kyT7TxyfFWvWZuHylZk++/FMHDMiO4wclrbWlpx64F65dvpDTa6W3rb3TuMze+HiPLZoSdZ1dOTKu+/L5L27zz00e+HiridT758zN+saHV1fnC3eEBjPXbIs101/ICcdoKt+Xzdr0ZKMHjo4IwcPSkspOWDnHXLv7Lnd2ixZuTq7jev8YmzIgP4ZM6zz4YJ+ra3p39b5DE+/1tbsPn5M10Mo9F0Td98j8x+fk4Xz5mb9+vW5/fprs/9hRzyt3aqVK/PgtKk54DlPbjvrJS/L+79wcd73ua/k5W/6h+yx34HCme3A7IVLMmbYkIwcMiitLSUH7rJjps96+n1m9/FPuc8sf/p9Zo8dxmbuEsNv9nV77bNv5syalcfnzMm6dety9R+vyFHHHNutzVHHHJepd96Rjo6OrFm9OvdNuycTd5mU1atWZdWGSd5Xr1qV2265ObvsulszToMa7bf33pk5e3ZmP/ZY1q1bl//505U5/ujJ3dosWLio6zPw1OnTU1VVRgwfnr9/9d/mF9//Tn76nW/lo+99d55zyMHCme3ALnvsmXmPzcmCuY9n/fp1ufW6q3Pgc458WrtVK1fkgXum5qDnHNW1bvnSJVm5ovPhx7Vr1+Teu+7IuJ0M9Qs8u2ftQVNV1Z+S/KmU8v+qqprxbO1JGlWVb1xxfT7wojPS0lJyxV335dEFi3PGwfskSX53x/RMHD0iF551YhpVI48uWJKvbuhNM3LIwLz7vM7JUVtbSq6a9mBue3hW086FejSqKt+64vq8/4Wnp6WU/OHu+zNzweKcvuGa+f0d0zNh9Ii8+cwT0qiqzFywOBf/vrM3zYghA/POc09N0nnNXD3todw+wzXT133gRWfk0F0nZMTggfnJ2/823/7DDWlr7QzwLrn57lx/34xM3mtSfnDhK7Nm3fp88heXJ0k6GlW+8Jsr8+lXnp+WUnLplKl5eN6mx9Sl72htackbn3dyPvijX6TRaOT0Qw/IpPYx+c0tdyZJzn7OQbl22v254o5paW1tSf+2trznBWd1Ddn5L//1myxbtSqtLa154/NOztCnzBFA31NVVS6dMjUvP/GIlFJy20MzM2/p8q55Hm558NFcOfWBnH/kQfm7M45LSXL5HdOzau26jBwyKC859rAkSUspueuROXng8fnP8Gr0Ba2trTn/Va/JNz718TSqRo488ZTsMHHnXHfF75Ikx5zaOcHy3bfcmL0PPCT9B7iPbO8aVZXf3Do1rzzpyJRSMuXBzvvMEXt03mdufuDRXHn3/fmLyQfn7888PqUk/3PH9Kxcuy6jhgzKXx3fOdJ2Sym5c8ac3P+Y+0xf19ramte/+cJ85H3vTkejkeeeeVZ22XW3/PaXlyRJnnfuedl50qQcfuRReesbXpuWlpLnnnVOJu22Wx6bMzuf+PAHknRO3n3iKc/N4Uce9UwvRx/Q1tqat//9G/O2f/pgOjoaef4Zp2f3SZPys1//JknygnPOzh+uvjo/+/WlaW1tyYD+A/LR977bfGjbsdbW1rzob1+Xi/71o2k0Gjn65NOy48675OoN81kdf/qZSZI7broh+xx8SAYMfPLzzJJFi/KDi76URqORqmrksKOPy4GHP/1hFYCnKpubk+BpDUvZO8k7k+yajYKdqqpOfbZ9X/TZb5vhgC3WagI+esiT2fTUv+/hPkPP/GjgHs0ugW3MIbvs2OwS2MZMeXh2s0tgG/JXxxiai54Zt96wxvTMTYvXNrsEtkHPO/wAf2z3op9ce6vv2HvRXx57eFOu32ftQbORnyS5OMk3knT0TjkAAAAAAAB9X08CmvVVVV3Ua5UAAAAAAABsJ3oS0PyylPKmJD9LsuaJlVVVmbwAAAAAAAB6iTmy+qaeBDR/s+Hfd220rkqy+9YrBwAAAAAAoO/b4oCmqqrderMQAAAAAACA7cUWBzSllFdtan1VVd/deuUAAAAAAAD0fT0Z4uzIjf4/MMlpSW5NIqABAAAAAADogZ4McfaWjZdLKSOSfG+rVwQAAAAAANDHtfwf9l2ZZK+tVQgAAAAAAMD2oidz0PwySbVhsTXJfkn+szeKAgAAAAAA6Mt6MgfNZzb6//okM6qqmrmV6wEAAAAAAOjzejIHzZ9KKeOTHLlh1X29UxIAAAAAAPCElpRml0Av2OI5aEopL0lyY5K/TPKSJDeUUl7cW4UBAAAAAAD0VT0Z4uz9SY6sqmpukpRS2pP8T5L/6o3CAAAAAAAA+qot7kGTpOWJcGaDBT3cHwAAAAAAgPSsB81vSymXJfnRhuW/SnLp1i8JAAAAAACgb9vigKaqqneVUl6Y5PgkJcnXq6r6Wa9VBgAAAAAA0EdtcUBTStktyW+qqvrphuVBpZRdq6p6uLeKAwAAAAAA6It6MofMT5I0Nlru2LAOAAAAAACAHuhJQNNWVdXaJxY2/L//1i8JAAAAAACgb9viIc6SzCulnFdV1SVJUko5P8n83ikLAAAAAABIktaW0uwS6AU9CWjemOQHpZQvb1iemeSVW78kAAAAAACAvm2LA5qqqh5IcnQpZWiSUlXVso23l1L+pqqq72ztAgEAAAAAAPqansxBkySpqmr5U8OZDd66FeoBAAAAAADo83oc0DwDg+ABAAAAAABsga0Z0FRb8VgAAAAAAAB9lh40AAAAAAAANduaAc01W/FYAAAAAAAAfVZbTxqXUs5JckCSgU+sq6rqoxv+ffPWLQ0AAAAAAKBv2uKAppRycZLBSU5J8o0kL05yYy/VBQAAAAAAJCnFDCN9UU+GODu2qqpXJVlUVdVHkhyTZOfeKQsAAAAAAKDv6klAs2rDvytLKTslWZdkt61fEgAAAAAAQN/WkzloflVKGZnk00luTVKlc6gzAAAAAAAAemCLA5qqqv55w3//u5TyqyQDq6pa0jtlAQAAAAAA9F1bHNCUUlqTnJNk1yf2K6WkqqrP9U5pAAAAAAAAfVNPhjj7ZZLVSe5M0uidcgAAAAAAAPq+ngQ0E6uqOrjXKgEAAAAAANhOtPSg7aWllDN6rRIAAAAAAIDtRE960Fyf5GellJYk65KUJFVVVcN7pTIAAAAAACCllGaXQC/oSUDz2STHJLmzqqqql+oBAAAAAADo83oyxNl9Se4SzgAAAAAAAPzf9KQHzZwkfyylXJpkzRMrq6r63FavCgAAAAAAoA/rSUDz0Iaf/ht+AAAAAAAA+F/Y4oCmqqqP9GYhAAAAAAAA24stDmhKKUckeX+SSRvvV1XVwb1QFwAAAAAAQJ/VkyHOfpDkXUnuTNLonXIAAAAAAAD6vp4ENPOqqrqk1yoBAAAAAACepqU0uwJ6Q08Cmg+VUr6R5PIka55YWVXVT7d6VQAAAAAAAH1YTwKaVyfZN0m/PDnEWZVEQAMAAAAAANADPQloDqmq6qBeqwQAAAAAAGA70dKDtteXUvbvtUoAAAAAAAC2Ez3pQXN8kr8ppTyUzjloSpKqqqqDe6UyAAAAAACAPqonAc3zeq0KAAAAAACA7cgWD3FWVdWMJDsnOXXD/1f2ZH8AAAAAAAA6bXHAUkr5UJL3JHnfhlX9kny/N4oCAAAAAADoy3oyxNkLkhyW5NYkqapqdillWK9UBQAAAAAAJElaWwxm1Rf15F1dW1VVlaRKklLKkN4pCQAAAAAAoG/rSUDzn6WUryUZWUp5fZL/SfLvvVMWAAAAAABA37XFQ5xVVfWZUsrpSZYm2SfJB6uq+n2vVQYAAAAAANBH9WQOmmwIZIQyAAAAAAAA/wfPGtCUUpZlw7wzT92UpKqqavhWrwoAAAAAAKAPe9aApqqqYXUUAgAAAAAAsL1oaXYBAAAAAAAA2xsBDQAAAAAAQM2edYgzAAAAAACgeUopzS6BXlBLQPPJHdfW8TL0EdW6Nc0ugW3N2NZmV8A25vUPVM0ugW3Md45c2uwS2MbM/8kPml0C25gDn3NCs0tgW3LNo5nzs+80uwq2IQvbPJ9Lz4waMarZJbAtuujnza4AtjmGOAMAAIBtiHAGAKBvENAAAAAAAADUTEADAAAAAABQMwENAAAAAABAzQQ0AAAAAAAANRPQAAAAAAAA1ExAAwAAAMD/Z+++46Oq8v+Pv89MEgikNzoEkA7Se7Uhzbbr6roudl0s2Nv6te6qa+8Komuva8VeVkWUIiBNSkLvLb3XmfP7IyEkJMDkt8wdM3k9H495kHvvuZP3feRwp3zuORcAADgsJNABAAAAAAAAAADAoRkT6ATwB0bQAAAAAAAAAAAAOIwCDQAAAAAAAAAAgMMo0AAAAAAAAAAAADiMAg0AAAAAAAAAAIDDKNAAAAAAAAAAAAA4jAINAAAAAAAAAACAwyjQAAAAAAAAAAAAOIwCDQAAAAAAAAAAgMNCAh0AAAAAAAAAAAAcmtsw1iIY8VcFAAAAAAAAAABwGAUaAAAAAAAAAAAAh1GgAQAAAAAAAAAAcBgFGgAAAAAAAAAAAIdRoAEAAAAAAAAAAHAYBRoAAAAAAAAAAACHUaABAAAAAAAAAABwGAUaAAAAAAAAAAAAh4UEOgAAAAAAAAAAADg0Y0ygI8APGEEDAAAAAAAAAADgMAo0AAAAAAAAAAAADqNAAwAAAAAAAAAA4DAKNAAAAAAAAAAAAA6jQAMAAAAAAAAAAOAwCjQAAAAAAAAAAAAOo0ADAAAAAAAAAADgMAo0AAAAAAAAAAAADgsJdAAAAAAAAAAAAHBoLhPoBPAHRtAAAAAAAAAAAAA4jAINAAAAAAAAAACAwyjQAAAAAAAAAAAAOIwCDQAAAAAAAAAAgMMo0AAAAAAAAAAAADiMAg0AAAAAAAAAAIDDKNAAAAAAAAAAAAA4jAINAAAAAAAAAACAw0ICHQAAAAAAAAAAAByaMSbQEeAHjKABAAAAAAAAAABwGAUaAAAAAAAAAAAAh1GgAQAAAAAAAAAAcBgFGgAAAAAAAAAAAIdRoAEAAAAAAAAAAHAYBRoAAAAAAAAAAIDDMMZMMMakGmM2GGNurWP7TcaY5ZWPVcYYjzEm7nDPSYEGAAAAAAAAAADgEIwxbknPSpooqaekc4wxPau3sdY+bK3tZ63tJ+nvkn601mYe7nlD/JQXAAAAAAAAAAAcBW4XYy0CbIikDdbaTZJkjHlH0mmS1hyi/TmS3j7Sk/JXBQAAAAAAAAAAjZYx5jJjzJJqj8sOatJG0vZqyzsq19X1XM0kTZD0wZF+LyNoAAAAAAAAAABAo2WtnSVp1mGamLp2O0TbUyTNO9L0ZhIjaAAAAAAAAAAAAA5nh6R21ZbbStp1iLZ/lg/Tm0kUaAAAAAAAAAAAAA5nsaQuxpiOxpgwVRRhPjm4kTEmWtJYSbN9eVKmOAMAAAAAAAAAADgEa225MeYqSV9Lckt6yVq72hgzrXL7zMqmZ0j6xlpb4MvzUqABAAAAAAAAAAA4DGvtF5K+OGjdzIOWX5H0iq/PyRRnAAAAAAAAAAAADqNAAwAAAAAAAAAA4DCmOAMAAAAAAAAA4HfMmEAngD8wggYAAAAAAAAAAMBhFGgAAAAAAAAAAAAcRoEGAAAAAAAAAADAYRRoAAAAAAAAAAAAHEaBBgAAAAAAAAAAwGEhgQ4QrJZs2KxZX82R1+vV+AF9dNaoIXW2W7dzj27499u65czJGtWza732RXD5deNWzfr2Z3mtV+P79tSfRgyssX3huk1648dFMkZyu1y69KRR6tWutSRp9qIV+nr5GklWJ/frpdOG9A3AEcBpv27collfz5XXWo3v10t/GjmoxvaFqRv1xo8LZYyp7DNj1Kv9/j6zXF8vWyVZ6eT+vXTa0P6BOAQ46ObTjtfwrsnKLijShc+9XWeb6RNHa1iXDiouK9cDH3+n9bvTJElDjmmvqyaMlttl9PnSNXrr56VORkeALF67XjM+/lxer9WEYQP15xPG1NkuddsOXfPkLN123lka07d31XqP16urHp+hhOgo/fOSqU7FRgBFdeujdqdNlVwupf8yR3t/+KzG9rj+I9TiuMmSJG9pibZ98IqKdm9Tk8SW6vTXq6raNYlP0q6vP9C+n752ND+ct2T9Zj3/1Q/yeq1OHtBbZ40eWme7dTv36PoX39KtZ07RqF5d67UvgktM36HqdOG1Mi6X9n73qXbMfqPG9vDW7dXliv9TRMeu2vrOLO389MB7ntYT/6QWJ5wqGaO9332iXV/8x+n4CICYY4eo03nTJZdLe3/4XDs/favG9sSRJ6rNKX+RJHmKi7TxpcdUuG2jJOmYy25RbP/hKsvN0vJbLnQ8OwIjumd/dTjrEhnj0r5532r3Nx/W2B4/eIxaj/+DJMlTUqwtb89U4c4tBxoYl3r//RGVZmdo3XP3OZgcQENFgcYPPF6vZnzxve6d+kclREXquhfe1LBundU+Mb5Wu5f/+5MGdO5Q730RXDxer2Z8PVf3nnOq4qMidN3L72lol45qnxhX1aZvclsN7dJRxhht3peuBz/8WjOnnast+zL09fI1euzCMxXqduvOdz7VoGM6qE1cTOAOCH7n8Xo148s5uvfcMyr6zL/f1dCuHWucK/p2bKehXTtV9Jm96Xrwwy818/KpFX1m2So9dtHZFX3mrdka1KUjfSbIfbU8RR8t+k23nXFinduHdumgtnExOvepN9SzbQtdN3msrnjxfbmM0TWTxurG12crLTdfMy89S/NSN2trWpbDRwAnebxePfPhp3pg2gVKiI7S9Mdnaniv7urQMqlWuxc/+0YDux1T6zk+mrtA7ZMSVVhS4lRsBJIxan/G+Vo360GV5WSq+zX/UM6apSreu6uqSUlmmtbNuE+eokJFdT9WHf50kVKeulslaXu09vHbq57n2DueUvaqJYE5DjjG4/XquS++031Tz1RCVKSufeFNDet2jNon1f7M9NK3czWgc3K990WQMS51vvgGrbr3WpVm7FO/f72ojCU/q6jaF6Pl+bna9PLjih9c86KCZu06qsUJp2rFbZfIW16u3rc9qsyl81W8Z4fDBwFHGZc6XXitVv/rBpVmpKnvvc8rc+k8Fe3cWtWkeN9u/fbPq+UpyFdM36E65pIbtfLOyyVJ++Z+qd3ffKgul98WqCOA04xLyX/+m1KeukulWRnqdevDyl65SEXVzhUlGXu15vH/k6ewQNG9BqjjuVdo9UM3V21vefwUFe3ZIXfT8EAcAYAGiCnO/GDdzj1qHRejVrExCnW7NaZXdy1M2Vir3aeLlmtkjy6Kbt6s3vsiuKzbtU+tYqPVMja64u/es4sWrt9co014WJiMMZKk4tJyqfLnHRlZ6t6mhZqGhsrtcql3+9ZakLrJ8WOAs9bt2qtWcTEH+kyvLlq4rubfvUafKSurWr8jPVPd27Q80Gc6tNECzjNBb+XWXcorKj7k9pHdOurrFSmSpDU79iqiaRPFRTRT9zYttDMzR7uzclXu8er7Ves1slsnp2IjQFK37VDrhHi1io9TaEiIxvbvo/mr1tZqN/unhRp9bC/FREbUWJ+WnaNFa9dpwrBBtfZBcGrevrOKM/aqNDNN1uNR1vKFiulVczRwwdb18hQVVv68QaHRsbWeJ7JLL5Vk7FNpVoYjuRE4VZ974mIUGuLWmN7dtCB1Q612n/6yTCN7dlFMXZ+ZjrAvgkvkMT1UvGeHSvbtkvWUK23+d4ofPLpGm7LcbOVvTJH1lNdYH94mWXnrV8tbWiJ5PcpZu1zxQ+oeGYrgEXlMDxXv3amSfbsr+syC7xU3cFSNNnnrV8tTkF/x84bVCotLrNqWm7JS5fl5jmZGYEUkd1Fx2m6VpO+V9ZQrc8nPiu1bc4Rm/qZUeQoLKn7enKqw2AMXB4TFxCum9yClzfvW0dwAGjafCzTGmGt8WQcpIy9fCVGRVcsJURHKyKv5op6em6cFKes1cdCx9d4XwScjL1+JUQe+3EqIjFBGXkGtdvNTN2nazDd1z38+0zWTj5ckdUiM06rtu5RbWKzisjIt2bhV6bn5jmVHYPjcZ1I2atqM13XPO5/omlMqRk50SIrXqm27lFtYVNFnNmxRei7nmcYuMSpCadXOHWm5FX0sMaq50qr1j4r1zQMREQ5Kz8lVYkx01XJiTLQycg56L5Odq3m/rdXkEYNr7T/j4y90yZTxclUWiRH8QqNjVZadWbVcmp1ZZwFmv4Qh45SbsrLW+rh+w5S5fIFfMuL3JSP34M89kco46D1sem6e5qds0KRBfeu9L4JPWFyiSjL2VS2XZOyr8WX64RRu36ToHn0VEhElV1gTxfYfribxLfwVFb8TYbEJKq3WZ0oz09QkLuGQ7VuMm6zsFb84EQ2/U2ExcSrNSq9aLs3KUGhM3CHbJ444UdmrD0z/3OFPF2vbR6/Keq1fc6LxchnDw4+PgP1d69H2/DrWXXCoxsaYy4wxS4wxS975/qd6B2vIbJ3n4Zp/5Flfz9GFJ46W21XzT+DLvmgc6vqrj+jWSTOnnavbz5ykN+ZWvHFslxCnM4cN0B1vz9Zd73yqjkkJtfoVglAd54o6+0z3zpp5+VTd/qcpemPOQkmVfWb4QN3x1se6663Z6tiCPoO62bpflA7xWoWgUtc55qCTzIzZFUWYg88fC1enKiYiQl3btfFjQPz+1PEqdIiTRUTnHoofMkY7Pn+35jO43YrpNUBZKxb5IyB+Z2wdJ5qDzzOzvpqji+r6zOTDvghCdf2RfXxTUrRzq3bMflO9b39CvW57TAVbN8h6PUc5IH536ugzh+oy0T37q8W4ydry9vN+DoXftTrPM3U3jeraW0kjTtT2j16TJMX0HqSyvJyqexgBgK+OeA8aY8w5kv4iqaMx5pNqmyIlHXLuAWvtLEmzJGnDW883qq9yEqIialyNnp6br/iDpv7YsGuvHnz/C0lSbmGRlqzfLLfL5dO+CD7xkTWvXE/Py1dc5KGvUO/dvrX2ZOUop7BI0c3CNb5fT43v11OS9OqcBUqgzwS9+Kh69pkObbTnk2p9pn8vje/fS5L06vfzlRBFn2ns9o+Y2S8xKkLpeQUKcbuVWO0q5f3rEdwSYqKUlp1TtZyWnaO4av1AktZt36n7X6+4wXJOQaEWrV0nt8ullK07tHB1ihavXafS8nIVFpfogTfe061//ZOjxwBnleVk1rjCNCwmTmW52bXahbdqp+Q/Xaz1Lz4iT2HNEQ9R3fuqcMcWlefn+jsufgcSoiIP+tyTp7iD3sOu37VHD7z/uaSKz0yL12+Sy2V82hfBpzRjn5rEH7gXWpP4pBpXuh/J3h8+094fPpMkdTjnbzVG4yA4lWamKaxanwmLS6yzzzRr10mdL71Jax68mdegRq40K0NhsQdGWYXFxqssJ7NWu/A2HdTxr1cp9Zl/qLyg4vUosnN3xR47WDG9B8qEhMod3kydL7hWG195wqn4ABqoIxZoJM2XtFtSgqRHq63Pk1R7XgKoa5uW2pmRrT1ZOYqPitDc1Sm66Q+TarR56ZpLqn5+7OOvNKRrJw3vfow8Xu8R90Xw6do6SbuycrQnO1fxkc01d8163XTaSTXa7MrMVqvYaBljtGFPmso8XkWFN5UkZRcUKqZ5M+3LydOClE165Pw/BuIw4KCurVtoV2b1c8V63XTGyTXa1Ogzu/epzOupu8+kbtQjF/DFaWM3P3WzzhhyrL5ftV4927ZQQUmpMvMLlVNYpLbx0WoZE6n0vAId37uL7v3gm0DHhZ91a9dGO9MytDsjSwnRkfpx2W+6dWrN88Trt99Q9fPDb3+ooT27amSfnhrZp6cunjJekrRiw2a9P+dnijONQMH2TWqa0FJhcYkqy8lUbL9h2vzmczXahMbEq9P512jz28+rJH1PreeI6zec6c0aka6tW2rX/s89kRGauypVN/+x5ueel6+9tOrnxz6q+Mw0okcXeTzeI+6L4JO3MUXhrdqqSWIrlWamKXHECUp96h6f9w+NilFZbraaxLdQ/JCxWnH73/yYFr8HeRtTFN6yrZoktlRpZroShx+v1Gf+WaNNWHySul/3T61/7j4VV7sRPBqn/K3r1TSpVUUBODtTcYNGaeNLj9VoExaboK6X3aqNrzyu4n27qtZvn/2Gts9+Q5IU2aW3Wp10GsUZAD45YoHGWrtV0lZJw/0fJzi4XS5dPuk43fHGB/Jaq5P69VaHpAR9sWSFJNWaQ9mXfRHc3C6Xpo0frTvf+URer9VJfXuoQ2K8vli6SpI0aUBvzU/dpO9/S5Hb5VJYaIhuOWN81Q3g7//gK+UVFcvtdmnayWMUUfklPIKX2+XStAnjdOfbs+X1enVSv14VfebX3yRJkwb20fyUDfp+ZYrcbpfCQkJ0yxkTD/SZ979QXlGR3C63pk0YR59pBO7443j1S26j6GZN9d71F+jlH35RiLtiyphPlqzWwvVbNbRLB7159VSVlJXrwdnfSZI8Xqsnv5irh6eeJpcx+nLZGm1Jq30VGYKL2+3WVX+YottmvSqv16uThwxQcssW+mx+xdRTU0YMCXBC/O54vdr20WvqculNMsal9MVzVbx3pxKGV9wzL33B92p90ukKaRah9n+omDnZej1KefIuSZIJDVNU117a+sFLATsEOMvtdunyScfr9tc/kNd6Nb5/xeeezxdXfGaaPPgwn5kOsS+CnNejjS89rt7/95jkcmvvD5+pcMdmtTzpdEnSnm8/Vmh0nPo98G+5w5tL1qvWk87S0uvPlaeoUN1vuF+hkVGy5eXa+O9H5SngHoxBz+vRpleeUK9bH5FcLu2b84WKdm5RyxNOlSTt+e4Ttf/D+QqNjFanC6+r2md/8a7rVXcqukc/hURGa9DT72nbBy9r35wvAnU0cILXqy3vvKBu0++ScbmVNv+/Ktq9XUmjKy6G3PfT12oz+WyFREQq+c/TJFW8n1n9wI2BTA2ggTOHml++VkNj/iDpQUlJqphk2kiy1tqoI+3b2KY4w//GlpUEOgIaGpc70AnQwFy6kZcl1M+rg5OO3AioJv2HTwMdAQ1MzMDRgY6ABmT3R68GOgIaGBPiywQqwAEh0bGBjoAGaOiMj7krnB8tSOHLDH8a3r1zQPpvfV6hH5J0irV2rb/CAAAAAAAAAAAANAauerTdS3EGAAAAAAAAAADgf1efETRLjDHvSvpYUtUcVNbaD492KAAAAAAAAAAAgGBWnwJNlKRCSeOrrbOSKNAAAAAAAAAAAOAnLlOfybDQUPhcoLHWXujPIAAAAAAAAAAAAI2FzwUaY8zLqhgxU4O19qKjmggAAAAAAAAAACDI1WeKs8+q/dxU0hmSdh3dOAAAAAAAAAAAAMGvPlOcfVB92RjztqT/HvVEAAAAAAAAAAAAQe5/ubNQF0ntj1YQAAAAAAAAAACAxqI+96DJU8U9aEzlv3sk3eKnXAAAAAAAAAAAAEGrPlOcRfozCAAAAAAAAAAAQGPhc4FGkowxp0oaU7k4x1r72dGPBAAAAAAAAAAAENzqM8XZA5IGS3qzctU1xpiR1tq/+yUZAAAAAAAAAACQywQ6AfyhPiNoJknqZ631SpIx5lVJyyRRoAEAAAAAAAAAAKgHVz3bx1T7Ofoo5gAAAAAAAAAAAGg06jOC5l+SlhljfpBkVHEvGkbPAAAAAAAAAAAA1JPPBRpr7dvGmDmquA+NkXSLtXaPv4IBAAAAAAAAAAAEK5+nODPGnCGp0Fr7ibV2tqRiY8zpfksGAAAAAAAAAAAQpOpzD5q7rLU5+xestdmS7jrqiQAAAAAAAAAAAIJcfQo0dbWtzz1sAAAAAAAAAAAAoPoVaJYYYx4zxnQ2xnQyxjwu6Vd/BQMAAAAAAAAAAAhW9RkBM13SHZLerVz+RtLtRz0RAAAAAAAAAACoYowJdAT4gc8FGmttgaRbD7XdGPO0tXb6UUkFAAAAAAAAAAAQxOozxdmRjDyKzwUAAAAAAAAAABC0jmaBBgAAAAAAAAAAAD6gQAMAAAAAAAAAAOCwo1mg4S5FAAAAAAAAAAAAPvCpQGOMcRtjHj5CsyePQh4AAAAAAAAAAICg51OBxlrrkTTQGHPIUTLW2leOVigAAAAAAAAAAIBgFlKPtsskzTbGvCepYP9Ka+2HRz0VAAAAAAAAAABAEKtPgSZOUoak46uts5Io0AAAAAAAAAAA4CeuQ09uhQbMpwKNMcYtKd1ae5Of8wAAAAAAAAAAAAS9+tyDZoCfswAAAAAAAAAAADQK9ZnibLkx5hNJ3IMGAAAAAAAAAADgf8A9aAAAAAAAAAAAABzmc4HGWnuhP4MAAAAAAAAAAAA0Fj7dg0aSjDFdjTHfGWNWVS4fa4y53X/RAAAAAAAAAAAAgpPPBRpJL0j6u6QySbLWrpT0Z3+EAgAAAAAAAAAACGb1KdA0s9YuOmhd+dEMAwAAAAAAAAAA0Bj4fA8aSenGmM6SrCQZY86UtNsvqQAAAAAAAAAAgCTJ5TKBjgA/qE+B5kpJsyR1N8bslLRZ0rl+SQUAAAAAAAAAABDEfC7QWGs3STrRGNNckstam1d9uzHmfGvtq0c7IAAAAAAAAAAAQLCpzz1oJEnW2oKDizOVrjkKeQAAAAAAAAAAAIJevQs0h8EkeAAAAAAAAAAAAD44mgUaexSfCwAAAAAAAAAAIGgxggYAAAAAAAAAAMBhR7NAM+8oPhcAAAAAAAAAAEDQCjlSA2PM9Yfbbq19rPLfq45WKAAAAAAAAAAAUMFlmMAqGB2xQCMp0u8pAAAAAAAAAAAAGpEjFmistfc4EQQAAAAAAAAAAKCx8GWKs6cOt91ae/XRiwMAAAAAAAAAABD8fJni7Fe/pwAAAAAAAAAAAGhEfJni7NXqy8aY5tbaAv9FAgAAAAAAAAAACG4uXxsaY4YbY9ZIWlu53NcY85zfkgEAAAAAAAAAAAQpnws0kp6QdLKkDEmy1q6QNMYPmQAAAAAAAAAAAIJafQo0stZuP2iV5yhmAQAAAAAAAAAAaBSOeA+aarYbY0ZIssaYMElXq3K6MwAAAAAAAAAA4B/GmEBHgB/UZwTNNElXSmojaaekfpXLAAAAAAAAAAAAqAefR9BYa9MlnevHLAAAAAAAAAAAAI2CzyNojDGdjDGfGmPSjDH7jDGzjTGd/BkOAAAAAAAAAAAgGNVnirO3JP1HUitJrSW9J+ltf4QCAAAAAAAAAAAIZvUp0Bhr7evW2vLKxxuSrL+CAQAAAAAAAAAABCuf70Ej6QdjzK2S3lFFYeZsSZ8bY+IkyVqb6Yd8AAAAAAAAAAAAQac+BZqzK//9mw6MnDGSLqpc5n40AAAAAAAAAAAAPqjPFGe3SOprre0o6WVJKyT90Vrb0VpLcQYAAAAAAAAAAMBH9RlBc7u19j/GmFGSTpL0qKQZkoYeacfX3O3+P+OhMWratD7dEpDKPd5AR0AD8+rg3EBHQANz/uJ9gY6ABuaVGx8LdAQ0MGm5+YGOgAakycCT1HLrykDHQAPiKSoMdAQ0MN7BJwQ6AoCDuI0JdAT4QX1G0Hgq/50saaa1draksKMfCQAAAAAAHArFGQAAgOBQnwLNTmPM85LOkvSFMaZJPfcHAAAAAAAAAACA6ldgOUvS15ImWGuzJcVJuskfoQAAAAAAAAAAAIKZzzf7sNYWSvqw2vJuSbv9EQoAAAAAAAAAACCYMUUZAAAAAAAAAACAwyjQAAAAAAAAAAAAOIwCDQAAAAAAAAAAgMMo0AAAAAAAAAAAADgsJNABAAAAAAAAAADAoRljAh0BfsAIGgAAAAAAAAAAAIdRoAEAAAAAAAAAAHAYBRoAAAAAAAAAAACHUaABAAAAAAAAAABwGAUaAAAAAAAAAAAAh1GgAQAAAAAAAAAAcBgFGgAAAAAAAAAAAIdRoAEAAAAAAAAAAHBYSKADAAAAAAAAAACAQ3MZE+gI8ANG0AAAAAAAAAAAADiMAg0AAAAAAAAAAIDDKNAAAAAAAAAAAAA4jAINAAAAAAAAAACAwyjQAAAAAAAAAAAAOIwCDQAAAAAAAAAAgMMo0AAAAAAAAAAAADiMAg0AAAAAAAAAAIDDQgIdAAAAAAAAAAAAHJoxJtAR4AeMoAEAAAAAAAAAAHAYBRoAAAAAAAAAAACHUaABAAAAAAAAAABwGAUaAAAAAAAAAAAAh1GgAQAAAAAAAAAAcBgFGgAAAAAAAAAAAIdRoAEAAAAAAAAAAHAYBRoAAAAAAAAAAACHhQQ6AAAAAAAAAAAAODS3ywQ6AvyAETQAAAAAAAAAAAAOo0ADAAAAAAAAAADgMAo0AAAAAAAAAAAADqNAAwAAAAAAAAAA4DAKNAAAAAAAAAAAAA6jQAMAAAAAAAAAAOAwCjQAAAAAAAAAAAAOo0ADAAAAAAAAAADgsJBABwAAAAAAAAAAAIdmjAl0BPgBI2gAAAAAAAAAAAAcRoEGAAAAAAAAAADAYRRoAAAAAAAAAAAAHEaBBgAAAAAAAAAAwGEUaAAAAAAAAAAAABxGgQYAAAAAAAAAAMBhFGgAAAAAAAAAAAAcFhLoAAAAAAAAAAAA4NBcxgQ6AvyAETQAAAAAAAAAAAAOo0ADAAAAAAAAAADgMAo0AAAAAAAAAAAADqNAAwAAAAAAAAAA4DAKNAAAAAAAAAAAAA6jQAMAAAAAAAAAAOAwCjQAAAAAAAAAAAAOo0ADAAAAAAAAAADgsJBABwAAAAAAAAAAAIfmcplAR4AfMIIGAAAAAAAAAADAYRRoAAAAAAAAAAAAHEaBBgAAAAAAAAAAwGEUaAAAAAAAAAAAABwWEugAweqYlgma1L+njDFaumm7fkrZVGN7k9AQnTm0r6Kbh8tljOalbtayzTskSddNGafSMo+81sprrZ7/dl4gDgEO69QiXicd213GGK3YskML1m2psb1JSIhOHdxHUeFN5XIZ/bJ+i1Zu3SW3y6WpYwbL7XLJ5TJK2blXP63dGJiDgKM6t0jQyf17yGWkZZt2aF7q5hrbm4SE6IyhxyqqWVO5jNGCdVu0YstOSdLVk8aqpLxc1lp5vVYvfrcgEIcABy1eu14zPv5cXq/VhGED9ecTxtTZLnXbDl3z5Czddt5ZGtO3d9V6j9erqx6foYToKP3zkqlOxUYA3Xza8RreNVnZBUW68Lm362wzfeJoDevSQcVl5Xrg4++0fneaJGnIMe111YTRcruMPl+6Rm/9vNTJ6AiQxb8s1Mynn5TH69XEyVN09rm1zxUrli3VzGeeUnl5uaKjY/TIU8+otKREN1x9lcrKSuXxeDR67HE676KLA3AEcNqKX5fo9RdmyOv1atxJE3Tqn86u1WbNbyv0xgvPy1NersioaN3+wMOSpC8//lBzvvlKxhi1TU7WZdfcoLCwMKcPAQ5btCZVz70/W16v1cQRQ3TO+OPqbJeydbuufuQZ3X7RuRrT/1hJ0rl3/kvhTZrI7TJyu1x67pZrnIyOAFmcsl4zP/mq4rVpyACdffzoOtulbt+pa59+Ubf99UyNPraXSsvKdMOMl1VW7pHH69XoPj113sl19zcElyW//KKZzzwpr8erCZOn6Kxz/1qrzcply/T8M0+p3FOuqOhoPfzkM1XbPB6Prv7bpUpISNA9DzzkZHQADRQFGj8wRpoysJdenbNIuUXF+ttJI5Wya5/ScvOr2gw9poP25ebrzZ9/VbMmYbp64hit3LpTHq+VJL38w0IVlpYF6hDgMCPp5L499PbPvyq3qFgXHjdM63enKT2voKrNwM7tlJ6br/cWLFOzsFD9bfwordq2Wx6vV2/+tERlHo9cxmjq2CHauCddu7JyAndA8DsjaeKAnnpj7mLlFhbrkhOHK3XXvhp9ZvAx7ZWWm6935i1Vs7BQXTlxtH7bukteW3GeeW3OIhVxnmkUPF6vnvnwUz0w7QIlREdp+uMzNbxXd3VomVSr3YuffaOB3Y6p9RwfzV2g9kmJKiwpcSo2Auyr5Sn6aNFvuu2ME+vcPrRLB7WNi9G5T72hnm1b6LrJY3XFi+/LZYyumTRWN74+W2m5+Zp56Vmal7pZW9OyHD4COMnj8ejZJx7Tvx59XAmJSZr+t0s0bOQodUjuWNUmPy9Pzzz+mO57+BEltWip7KyKPhEaFqaHHn9S4c2aqby8XNdfdbkGDx2qHr16H+rXIQh4PR69OvNZ3frP+xUXn6A7r79aA4cOU5v2HaraFOTn65UZz+rmu+9VQlKScrKzJUmZGen65tPZevC5WQpr0kRPPXCfFs6dozEnjg/Q0cAJHq9XT//nIz141aVKjInWlQ8/rRF9eqpDqxa12r04+wsN6tG11nM8es3fFB3R3KnICDCP16tnP/pC/7psasV74Kde0LBe3dShRe33wP/+/FsN7Na5al1oSIge+tv5Cm/SROUej65/9iUN7n6MenRo5/RhwEEej0fPPvmY7n/kcSUkJuqaaZdq6MiRtd/PPPGo7n3oUSW1aFH1fma/2R+8p/YdOqiwoODgpweAOvk0xZkxpokv61ChbVyMMvMKlVVQJI/X6rdtu9W9Tc03jVYVo2gkKSzEraLSMnkrizNofFrHRSuroFDZhUXyWqs1O/aoS6uabxqtlcIq+0xoSEhFn6n8or3M45EkuVxGbpdxNjwCok1cjLLyC5VdUNFnVm/fo251nGfCQvafZ2r2GTQuqdt2qHVCvFrFxyk0JERj+/fR/FVra7Wb/dNCjT62l2IiI2qsT8vO0aK16zRh2CCnIuN3YOXWXcorKj7k9pHdOurrFSmSpDU79iqiaRPFRTRT9zYttDMzR7uzclXu8er7Ves1slsnp2IjQFLXrlXrNm3VqnUbhYaGatzxJ2rBzz/XaPPDf7/VyDFjlNSipSQpJjZWkmSMUXizZpKk8vJyeco9Mob3M8Fu4/pUtWjVSkktWykkNFTDxozVr7/UHNE7/8cfNHj4CCUkVbwvjo6Jqdrm8XpUWlox6qq0pESxcfFOxkcApG7ZrtYJCWqdEK/QkBCNG9BX81aurtXu4x/naXTfPrXez6DxSd22U60T4qreA4/r11sLVqfWajd73i8a1aenYpofKN4ZYxTepOJrr3KPRx4vr02NwbqUtWrdpo1atW6t0NBQjT3+BC2cV/P9zJzv/quRo8cqqUXF5+/972ckKW3fPi1auEAnT57iaG4ADZuv96Cpa+4b5sM5hMjwpsqp9oVGbmGRosJr1rN+Wb9FiZERuunU43XlyaP15bI1qvra1ErnjRuiaSeN1MBOXJ3RGEQ2barcan0mr6hYkQf1mV83bVNCZHNdPWmsLj1xuL5dmVK1zUi6+PhhunbyOG3em8HomUYgMryJcgqLqpZzC2v3mcUbtioxqrmumzJO004eqa+XHegzVlZ/HTNIl5w4XAM6tnUsNwIjPSdXiTHRVcuJMdHKyMmr2SY7V/N+W6vJIwbX2n/Gx1/okinj5eJDKapJjIqoMTo4LTdfiVERSoxqrrTcvIPWc7VysMtIT1Ni0oGLSxISE5WenlajzY4d25Wfl6ebrrlKV156kb796suqbR6PR5dffIHOPv0U9R80SN179nIsOwIjKyNDcQmJVctx8QnKysio0WbPrp0qyM/XvX+/Sbdfe5V++v6/VW0nnXGmrrloqq467y9q1ry5+gwY6Gh+OC89J0dJsdXez8RGKyMnt2ab7BzNW7FKU0YPq7W/MdItz7ygyx98Up/9vNDveRF4Gbm5SoyJqlpOiI5S+sF9JidX81elaPLw2hciebxeXf7YDJ19z8Pq36Wzurfnc1OwS09LU2JizfczGWnpNdrs2L5d+fl5uvma6Zp+2cX679dfVW17/pmndPHfrpDLcMtvAL477BRnxpiWktpICjfG9FfF98CSFCWp2RH2vUzSZZI0+ZKrNODEif972gairq+vDr5m/ZiWidqdnauX5/yiuIhmOn/sEG39+meVlJfrxe8WKK+4RM2bhOn8cUOUnpfPtCDBzofvPDslJWhvdp7e/GmJYpuH65xRg/Ri+nyVlntkJf37+4UV9zYa1q/Wl2YIQj6caDq3SNCe7Dy99uNixTZvpr+OHaSt32SqtNyjl7//RfnFJWrWJEx/HTNI6XkF2pbOeSZo1TFw6uBay4zZFUUYt6vmh4mFq1MVExGhru3aaMWGmvc5Ag5mDzFKj8F7wa+uv7056MXK4/Fo/bpUPfjYkyopKdG1V0xTj1691LZde7ndbs349yvKz8vTPbffpi2bNim5EyOvglmd54uDXpy8Ho82b9ygv9/7gMpKSnT3TdfpmG7dFRUdraW/LNDjL76iZs0j9PQD9+nnH77TqONOcCg9AsGX15LnPvhEl5w2qdb7GUl64rorlBATray8fN3yzAtq3zJJxx7DeSaY1X2aqXmemfnJV7p40ol19hm3y6UZ11+u/KIi3fPqu9qyZ6+SW7ao1Q5B7qDPTV6PR+tTU/XAY0+opKRE1195ubr37Kmd27crJjZWXbp108plywKTFUHP5csXiGhwjnQPmpMlXSCpraTHqq3Pk3Tb4Xa01s6SNEuS7nz3i0b1sTy3qFjR4U2rlqOahSuvqOac/QM6tq26kXtmfqGyCgqVENVcOzNzlFdc0bagpFRrd+xV27gYCjRBLq+oWFHV+kxkeNNafebY5NZaUHkT+KyCImUXFCk+srl2Zx24AqikrFxb0zLVqUU8BZogl1dYouhm4VXLUc2aVp079uvXsY3mpezvMxXToSVERmhXVo7yK9sWlpQqdec+tYmLpkATxBJiopSWfWBkXVp2juKiImu0Wbd9p+5//T+SpJyCQi1au05ul0spW3do4eoULV67TqXl5SosLtEDb7ynW//6J0ePAb8/+0fM7JcYFaH0vAKFuN1KrNa/9q9HcEtITFLavn1Vy+lpaYpPSKjRJjExUdHR0WoaHq6m4eHq07evNm3YoLbt2le1iYiMVN/+/bV40UIKNEEuLiFBmdVGWWVmpCs2Lq5Gm9j4BB0bFaWmTZuqadOm6t67t7Zt3iRJSmzRQlHRMZKkQSNGav3atRRoglxiTLT2VZspIC0rR/HRUTXarNu2Q/e9/JYkKSe/QItWp8jtcmlk395KqBxNHBsZoZHH9lLKlu0UaIJcQnSU0rIPfF5Oz8lVfK33wLv0rzffl1T5Hjhlvdwul0b07lHVJiI8XH07JWtxygYKNEEuITFRaWmHfz+TkJioqGrvZ3r37avNGzdqw7pULZw3T4sXLlRZaakKCwv00L3/0M233+n0YQBoYA475s5a+6q19jhJF1hrj6v2ONVa+6FDGRucnZk5iotsrpjm4XK7jPq0b6WUnXtrtMkuLFKnFhUn+eZNwpQQGaGs/EKFut0KC3FLkkLdbnVumaC9B01Dg+CzKytXsRHNFN0sXC5j1LNtS63fva9Gm9zCYiUnVcyt3bxJmOIjmym7oEjNwkKr7mcU4nKpY1K8MvgiLOjtzMpRXEQzxVT2mV7tWmrdrpp9JqewWB1r9JnmyiqofZ7p1CJe+3Io6AWzbu3aaGdahnZnZKmsvFw/LvtNw3t3r9Hm9dtv0Ot3VDxG9+2l6X+copF9euriKeP11l036fU7btBtU89Svy4dKc5AkjQ/dbNO7lvRj3q2baGCklJl5hcqdddetY2PVsuYSIW4XTq+dxfNT2X0VbDr1r27du7Yrj27d6msrExzvv+vho0cWaPN8JGjtWrlSnnKy1VcXKyUtWvUvkOysrOzlJ9X8X63pKRES5csUbtqN4pHcOrUpZv27NqlfXv2qLysTAvn/qgBQ2pOSzVw2HClrl4tj8ejkuJibUxNVet27RWfmKQNKSkqKS6WtVarVyxXm3ZMDR3sunVoq51p6dqdnqmy8nLNWbpCI47tWaPNG/f8XW/+o+Ixpn8fXX32GRrZt7eKSkpVWFwxpXRRSal+TVmv5NYtA3EYcFC3dq21Mz1DezIr3gPPWb5Kw3p2q9Hmtduu1Wu3XafXbrtOo/v01PQ/TNaI3j2UnV+g/KKKKaVLysq0dMMmtUtKqOvXIIh07dZdu3bsqHo/8+P332nYiFE12gwbNUqrfltR9X4mdc0atWvfQRdeNk1vvP+hXn33Pd16593q238AxRkAPjnSCJr9PjPG/EVScvV9rLX/8Eeohs5rrT5fulrnjR0il5GWbtqhtNx8DepccXXgko3b9OPqDTpj6LG68uTRkpG+WZmiwtKyyqmrKuZPdhmjlVt3acOe9MP9OgQBa62+WZ6iP48cIJcxWrF1p9LzCtS/8t4gyzbv0M8pmzRlYC9dcsJwGRl9v2q9ikrLlBgVoVMG9ZbLGBkZrd25hz7TCFhr9eWyNTp3zCAZY7R8c8V5Zv99q37dtF1z12zUaYP76G/jR8pI+m5lqopKyxTTPFxnjegvqeI8s2rbbm3cS58JZm63W1f9YYpum/WqvF6vTh4yQMktW+iz+YskSVNGDAlwQvwe3fHH8eqX3EbRzZrqvesv0Ms//KIQd8W1PZ8sWa2F67dqaJcOevPqqSopK9eDs7+TJHm8Vk9+MVcPTz1NLmP05bI12pKWGchDgQPcISG68trrdduN18vr9Wr8pMlK7thJn83+WJI05bTT1T45WYOGDNW0iy6QcRlNmHyKkjt10qaNG/TI/ffJ6/XKa70aM+54DRsx8vC/EA2e2+3W+dOu0EN3/Z+8Xq/GnjhebTsk67svP5cknTBxstq0a69jBw7U36dfLpcxGjd+gtp1SJYkDRk5Wrdfe5Xcbrc6dOqs4yY0nim1Gyu3263pZ52mW599UV7r1YRhg5XcqqU+/ani9rinjB5+yH2z8vJ09wuvSZI8Hq+OH9RPQw76oh7Bx+1268rTJ+m2F16X12s1fkh/JbdM0mcLFkuSpgyvfe/F/TJz8/TIux9XvjZZjenbq1ZxB8HHHRKiy6+5TrffdIM8Xq/GT5ysDh076vPK9zOTTztd7TtUvJ+5/OIL5DIunTx5CqN+AfxPzKHmCq/RyJivJOVI+lWSZ/96a+2jvvySxjbFGf43TUN9rRsCFco93kBHQANzfrPcIzcCqjl/8b4jNwKqeWXa2YGOgAaG6WlRHy23rgx0BDQwnqLCQEdAA+MdzLSRqL9OrZK4SYof7diXwXfsftQ2KT4g/dfXb8LbWmsn+DUJAAAAAAAAAABAI3HYe9BUM98Y08evSQAAAAAAAAAAABoJX0fQjJJ0gTFms6QSSUaStdYe67dkAAAAAAAAAAAAQcrXAg13XAQAAAAAAAAAADhKfC3QcAMiAAAAAAAAAAACwJiA3MMefuZrgeZzVRRpjKSmkjpKSpXUy0+5AAAAAAAAAAAAgpZPBRprbZ/qy8aYAZL+5pdEAAAAAAAAAAAAQc71/7OTtXappMFHOQsAAAAAAAAAAECj4NMIGmPM9dUWXZIGSErzSyIAAAAAAAAAAIAg5+s9aCKr/VyuinvSfHD04wAAAAAAAAAAAAQ/X+9Bc48kGWMiKxZtvl9TAQAAAAAAAAAABDGf7kFjjOltjFkmaZWk1caYX40xvf0bDQAAAAAAAAAAIDj5VKCRNEvS9dbaDtbaDpJuqFwHAAAAAAAAAACAevL1HjTNrbU/7F+w1s4xxjT3UyYAAAAAAAAAAFDJZQKdAP7ga4FmkzHmDkmvVy7/VdJm/0QCAAAAAAAAAAAIbr5OcXaRpERJH1Y+EiRd6K9QAAAAAAAAAAAAwcynETTW2ixJV/s5CwAAAAAAAAAAQKPg0wgaY8y3xpiYasuxxpiv/ZYKAAAAAAAAAAAgiPk6xVmCtTZ7/0LliJokvyQCAAAAAAAAAAAIcr4WaLzGmPb7F4wxHSRZ/0QCAAAAAAAAAAAIbj7dg0bS/0n62RjzY+XyGEmX+ScSAAAAAAAAAABAcPOpQGOt/coYM0DSMElG0nXW2vT9240xvay1q/2UEQAAAAAAAAAAIKj4OoJGlQWZzw6x+XVJA45KIgAAAAAAAAAAUMXl8vVuJWhIjtZf1Ryl5wEAAAAAAAAAAAh6R6tAY4/S8wAAAAAAAAAAAAQ9xkUBAAAAAAAAAAA47GgVaEqP0vMAAAAAAAAAAAAEvRBfGxpj2kjqUH0fa+3cyn+HHf1oAAAAAAAAAAAAwcmnAo0x5kFJZ0taI8lTudpKmuunXAAAAAAAAAAAAEHL1xE0p0vqZq0t8WMWAAAAAAAAAACARsHXe9BskhTqzyAAAAAAAAAAAACNha8jaAolLTfGfCepahSNtfZqv6QCAAAAAAAAAACSJJcxgY4AP/C1QPNJ5QMAAAAAAAAAAAD/I58KNNbaV/0dBAAAAAAAAAAAoLHwqUBjjNksyR683lrb6agnAgAAAAAAAAAACHK+TnE2qNrPTSX9SVLc0Y8DAAAAAAAAAAAQ/Fy+NLLWZlR77LTWPiHpeP9GAwAAAAAAAAAACE6+TnE2oNqiSxUjaiL9kggAAAAAAAAAACDI+TrF2aPVfi6XtEXSWUc9DQAAAAAAAAAAQCPgU4HGWnucv4MAAAAAAAAAAIDajAl0AviDT/egMcZEG2MeM8YsqXw8aoyJ9nc4AAAAAAAAAACAYORTgUbSS5LyVDGt2VmSciW97K9QAAAAAAAAAAAAwczXe9B0ttb+sdryPcaY5X7IAwAAAAAAAAAAEPR8HUFTZIwZtX/BGDNSUpF/IgEAAAAAAAAAAAQ3X0fQXC7p1Wr3ncmSdL5/IgEAAAAAAAAAAAQ3Xws0ayU9JKmzpBhJOZJOl7TSL6kAAAAAAAAAAACCmK8FmtmSsiUtlbTTb2kAAAAAAAAAAAAaAV8LNG2ttRP8mgQAAAAAAAAAAKCR8LVAM98Y08da+5tf0wAAAAAAAAAAgBrcLlegI8APfC3QjJJ0gTFms6QSSUaStdYe67dkAAAAAAAAAAAAQcrXAs1Ev6YAAAAAAAAAAABoRHwq0Fhrt/o7CAAAAAAAAAAAQGPBxHUAAAAAAAAAAACHYYyZYIxJNcZsMMbceog244wxy40xq40xPx7pOX2d4gwAAAAAAAAAAKDRMca4JT0r6SRJOyQtNsZ8Yq1dU61NjKTnJE2w1m4zxiQd6XkZQQMAAAAAAAAAAHBoQyRtsNZustaWSnpH0mkHtfmLpA+ttdskyVq770hPSoEGAAAAAAAAAAA0WsaYy4wxS6o9LjuoSRtJ26st76hcV11XSbHGmDnGmF+NMecd6fcyxRkAAAAAAAAAAGi0rLWzJM06TBNT124HLYdIGijpBEnhkhYYYxZaa9cd6kkp0AAAAAAAAAAA8Dvmqqs8ACftkNSu2nJbSbvqaJNurS2QVGCMmSupr6RDFmiY4gwAAAAAAAAAAODQFkvqYozpaIwJk/RnSZ8c1Ga2pNHGmBBjTDNJQyWtPdyTMoIGAAAAAAAAAADgEKy15caYqyR9Lckt6SVr7WpjzLTK7TOttWuNMV9JWinJK+lFa+2qwz0vBRoAAAAAAAAAAIDDsNZ+IemLg9bNPGj5YUkP+/qcTHEGAAAAAAAAAADgMAo0AAAAAAAAAAAADqNAAwAAAAAAAAAA4DAKNAAAAAAAAAAAAA4LceKXdG2Z4MSvQZBwGRPoCGhgmjcJC3QENDDp770Z6AhoYF658bFAR0ADc8HMdwMdAQ3M0xecHugIaEDCkloHOgIaGE9BXqAjoIFpUpAZ6AhokJICHQBocBwp0AAAAAAAAAAAgP8/LmsDHQF+wBRnAAAAAAAAAAAADqNAAwAAAAAAAAAA4DAKNAAAAAAAAAAAAA6jQAMAAAAAAAAAAOAwCjQAAAAAAAAAAAAOo0ADAAAAAAAAAADgMAo0AAAAAAAAAAAADqNAAwAAAAAAAAAA4LCQQAcAAAAAAAAAAACHYb2BTgA/YAQNAAAAAAAAAACAwyjQAAAAAAAAAAAAOIwCDQAAAAAAAAAAgMMo0AAAAAAAAAAAADiMAg0AAAAAAAAAAIDDKNAAAAAAAAAAAAA4jAINAAAAAAAAAACAwyjQAAAAAAAAAAAAOCwk0AEAAAAAAAAAAMChWY8n0BHgB4ygAQAAAAAAAAAAcBgFGgAAAAAAAAAAAIdRoAEAAAAAAAAAAHAYBRoAAAAAAAAAAACHUaABAAAAAAAAAABwGAUaAAAAAAAAAAAAh1GgAQAAAAAAAAAAcBgFGgAAAAAAAAAAAIeFBDoAAAAAAAAAAAA4DGsDnQB+wAgaAAAAAAAAAAAAh1GgAQAAAAAAAAAAcBgFGgAAAAAAAAAAAIdRoAEAAAAAAAAAAHAYBRoAAAAAAAAAAACHUaABAAAAAAAAAABwGAUaAAAAAAAAAAAAh1GgAQAAAAAAAAAAcFhIoAMAAAAAAAAAAIDDsN5AJ4AfMIIGAAAAAAAAAADAYRRoAAAAAAAAAAAAHEaBBgAAAAAAAAAAwGEUaAAAAAAAAAAAABxGgQYAAAAAAAAAAMBhFGgAAAAAAAAAAAAcRoEGAAAAAAAAAADAYSGBDgAAAAAAAAAAAA7NeryBjgA/YAQNAAAAAAAAAACAwyjQAAAAAAAAAAAAOIwCDQAAAAAAAAAAgMMo0AAAAAAAAAAAADiMAg0AAAAAAAAAAIDDKNAAAAAAAAAAAAA4jAINAAAAAAAAAACAwyjQAAAAAAAAAAAAOCwk0AEAAAAAAAAAAMChWesNdAT4ASNoAAAAAAAAAAAAHEaBBgAAAAAAAAAAwGEUaAAAAAAAAAAAABxGgQYAAAAAAAAAAMBhFGgAAAAAAAAAAAAcRoEGAAAAAAAAAADAYRRoAAAAAAAAAAAAHEaBBgAAAAAAAAAAwGEhgQ4AAAAAAAAAAAAOw9pAJ4AfMIIGAAAAAAAAAADAYRRoAAAAAAAAAAAAHEaBBgAAAAAAAAAAwGHcg8ZPNqxaqa/ffV3W61X/UeM0cuIpNbbP//pzrfplviTJ6/Uoffcu3fDYcyrIy9OHs56papeVvk/jTv2jhp44wdH8cN6GVSv01Tuvy+v1asDocRo18dQa2+d9/Zl+W7i/z3iVvnunbnp8hgrycvX+8zX7zHGnnalh9Jmgl7pyuWa/8bKs16shY0/QcaecXmP7nM8/0bIFP0mSvB6v9u3aobue/beaRURUrPN69dSdtyoqNk4X3XCr0/HhsKhufdTutKmSy6X0X+Zo7w+f1dge13+EWhw3WZLkLS3Rtg9eUdHubWqS2FKd/npVVbsm8Una9fUH2vfT147mh/MW/7JQM59+Uh6vVxMnT9HZ506t1WbFsqWa+cxTKi8vV3R0jB556hmVlpTohquvUllZqTwej0aPPU7nXXRxAI4ATrv5tOM1vGuysguKdOFzb9fZZvrE0RrWpYOKy8r1wMffaf3uNEnSkGPa66oJo+V2GX2+dI3e+nmpk9ERIMsWL9LLM5+V1+PVCRMn6Yyzz6nVZtWK5Xpl5nMqLy9XVHS0/vHI45Kkgvx8zXj8EW3bskXGGF1x/Y3q1rOX04cAh/2yfIWeerniM9PkE8bpr6fX/My0bPUa3fbQ42qVlChJGjN0sC448wxJ0gPPzdL8pcsVGx2lVx99wPHsCIxFv63WM2/9Rx6v1eQxI/WXySfX2S5l0xZdee9DuvPySzR28ABJ0ntff6fP586TMVKntm10y8XnKSw01Mn4CICFS5bqiVkvyOP16pTxJ+m8s86ssX3pyt90yz/vV+sWLSRJY0cM00V/+XPVdo/Ho4uuvUGJ8fF65O47HM0OoGGiQOMHXq9XX731qs697hZFxcbpxfvvVNe+A5TYuk1VmxEnT9aIkyu+CFu3Yql++e9XCm8eofDmEbrszvuqnueJm69Wt/6DAnIccI7X69UXb72qqddVfFn+wn13qlvfgTX6zMiTp2jkyVMkSakrlmrhtwf6zLS77q96nsdumq7u9Jmg5/V69dFr/9alN9+u6Lh4PX3X39VzwCC1aNO2qs24yadq3OSKD61rli3RT199XlWckaSfv/5CSa3bqLioyPH8cJgxan/G+Vo360GV5WSq+zX/UM6apSreu6uqSUlmmtbNuE+eokJFdT9WHf50kVKeulslaXu09vHbq57n2DueUvaqJYE5DjjG4/Ho2Sce078efVwJiUma/rdLNGzkKHVI7ljVJj8vT888/pjue/gRJbVoqeysLElSaFiYHnr8SYU3a6by8nJdf9XlGjx0qHr06h2ow4FDvlqeoo8W/abbzjixzu1Du3RQ27gYnfvUG+rZtoWumzxWV7z4vlzG6JpJY3Xj67OVlpuvmZeepXmpm7U1LcvhI4CTPB6PXnz2Kd35r4cUl5CoW6dfoUHDhqtdh+SqNgX5+XrxmSf1f/c9oMSkFsrJPtAnXprxjPoNGqwb77hbZWVlKi0pCcBRwEker1eP//tVPXb7rUqMj9Nlf79TowYNVHLbNjXaHdujmx689cZa+08YN0ZnTDhJ9z/7vFOREWAer1dPvv6OHr7xaiXGxWraPx7QiH7HKrlNq1rtZr33kQb37lm1Li0rWx/+9we9ct+dahIWprufe0Hf/7JEE0YNd/ow4CCPx6NHZjyvJ++9R0kJ8br4uhs1etgQdWzfvka7vr16HrL48p9PPlNyu3YqKCx0IjKAIODzFGfGmJG+rIO0a/NGxSa1UGxiktwhIeo1eJhSV/x6yParFi9UryG1X+Q3r12t2MQkxcQn+DMufgd2bt6ouMSafSZl+WH6zKIF6n2IPhNHn2kUtm/coISklopPaqGQkBD1HTZCq5cuPmT75Qvmqd+wA6fs7MwMpaxYqiHjTnAiLgKsefvOKs7Yq9LMNFmPR1nLFyqm18AabQq2rpenqLDy5w0KjY6t9TyRXXqpJGOfSrMyHMmNwEldu1at27RVq9ZtFBoaqnHHn6gFP/9co80P//1WI8eMUVKLlpKkmNiKPmOMUXizZpKk8vJyeco9MsY4ewAIiJVbdymvqPiQ20d266ivV6RIktbs2KuIpk0UF9FM3du00M7MHO3OylW5x6vvV63XyG6dnIqNANmQmqKWrduoRavWCg0N1chxx2nxgvk12vz0w3caOnK0EpMqrlKOjqk4zxQWFGjtb7/phAmTJEmhoaFqXu0iFASntRs2qk3LFmrdIkmhISE6YcQw/bz40J+ZDtavZ3dF0U8alZRNW9Q6KVGtkxIVGhKi44cM0rxlK2q1++i/P2j0oP6KiYqssd7j8aqktEwej0clpaWKj4l2KjoCZM269WrbuqXatGqp0NBQnThmtH5auMjn/felp2v+4iU65eST/JgSQLCpzz1onvZxXaOXm52lqLi4quWomDjlZdV9BWBZSYk2rlqpHgMG19q2evFC9R7M1RmNQd7BfSY2TnnZh+4zG1atVM+BtfvMqsV1F24QfHKyMhUdH1+1HB0Xr9yszDrblpaUKPW35eozeFjVuk/ffEWTzv4rX5o2EqHRsSrLPtA/SrMz6yzA7JcwZJxyU1bWWh/Xb5gyly/wS0b8vmSkpykxKalqOSExUenpaTXa7NixXfl5ebrpmqt05aUX6duvvqza5vF4dPnFF+js009R/0GD1J1phyApMSpCabn5VctpuflKjIpQYlRzpeXmHbS+eSAiwkGZGelKSEysWo5PSFRmenqNNrt37FB+fp7uvOl63XzlNM359htJ0t49uxUVHa1nH31IN17xN814/BEVFzMiONilZ2YpKf7AZ6bE+DilZdb+zLR63QZdeNNtuun+h7R5+w4nI+J3Jj0rW0lxB97zJsbFKj0ru0abtKxs/bR0hU49bkyN9YmxMTprwok6+8b/0x+vvVXNw8NrjLBBcErLyFCLhAMXvCYmxCsto/bFaatSUnXeVdfo+jvv0aat26rWPzHrRV154fly8TkbQD0csUBjjBlujLlBUqIx5vpqj7sluQ+z32XGmCXGmCXff/rRUYzcAFhba9WhvgRdt3KZ2h3TReHNa17J4ykv17oVS9Vj0BC/RMTvi62jzxxK6splan9M1zr7TOqKpeo5aOjRjoffpbr6TN3nmTXLflVyl25V05utWfarIiKj1bYjVyc3HnX0jUOcdyI691D8kDHa8fm7NZ/B7VZMrwHKWuH7FWRouOp6XTIH9SOPx6P161L1zwce1v0PP6a3XntVO7ZXfEB1u92a8e9X9OZ7Hyp17Vpt2bTJkdxoeA71Hqgeb43QQNX1Nz74M5PH49Gm9et12z/v0+33P6j333pDu3Zsr1i/Yb3GTzlVjzz3vJo0baqP3n3HoeQIlDpfmw56i9O1Y7L+89wTevnh+/WHCeN128OPO5QOv0e2js9MB59nnn3rPf3tT6fL7ar59VheQYHmL1uhtx/6p95//AEVl5Tq2/m/+DUvfgfqem066D1wt2M668OXX9BrzzypM0+ZrFvvrZhyft6ixYqNjlH3Lsc4kRRAEPHlHjRhkiIq21Yf75kr6cw695BkrZ0laZYkvfHjokb1ESsqNk65mQeuVM7NzlRETEydbVcvXqhedYyS2bBqhVq1T1ZEFENoG4NafSYrU5ExdV/dvvoQ05utp880KtGx8cqpdiVPTmaGomLr7jMrfpmnfsNGVS1vXZ+qNcuWKGXlMpWVlaqkqEhvz3xK50y72u+5ERhlOZkKjTlwxWlYTJzKcrNrtQtv1U7Jf7pY6198RJ7C/Brborr3VeGOLSrPz/V3XPwOJCQmKW3fvqrl9LQ0xSfUnD4zMTFR0dHRahoerqbh4erTt682bdigtu0OzNEdERmpvv37a/GihUruRFG4sds/Yma/xKgIpecVKMTtVmK1aWX2r0dwi09IUHragZF5Gelpiq02OliS4hMTFRkdraZNw9W0abh69umjLZs2qUfvPopPTFTX7j0kScNGjdHH/6FAE+wS4+O0L+PAZ6a0jEwlHPT+t3nlFJuSNHxAPz3+71eUnZtXa+oqNA6JsbHaV22UVVpmVq1pylK3bNU/ZvxbkpSTX6BfVq6S2+1SucejlokJVX1n9MB+WrVhk04awQWRwSwxIV57q43mTEvPUEK1kXtSzfPMiMGD9Mhzzys7J1cr16zVz78s0oIlv6q0tFQFRYW6++HHdPdN1zuWH42A9QY6AfzgiCNorLU/WmvvkTTMWntPtcdj1tr1DmRscFond1Lmvj3KSt8nT3m5Vi9eqK59B9RqV1xYqK3rUtStX+1tqxYtqPO+NAhObZI7KWPfHmWlHegz3Q7RZ7Ycps8wvVnj0bZTZ6Xv3a3MtH0qLy/XioXz1bP/oFrtigoLtSlljXoNPLBt4ll/0f89OVN/f+xZnXvFtercozfFmSBXsH2Tmia0VFhcoozbrdh+w5S9emmNNqEx8ep0/jXa/PbzKknfU+s54voNZ3qzRqRb9+7auWO79uzepbKyMs35/r8aNrLmrQeHjxytVStXylNeruLiYqWsXaP2HZKVnZ2l/LyK6apKSkq0dMkStWvfIRCHgd+Z+ambdXLf7pKknm1bqKCkVJn5hUrdtVdt46PVMiZSIW6Xju/dRfNTNwc4LfztmG7dtXvnTu3ds1tlZWWaN+cHDR42okabwcNHaO2q3yru/1BcrPUpKWrbvr1i4+IUn5Condu3S5J+W75MbTnPBL3unTtpx+492rVvn8rKy/Xd/IUaOajm56KM7OyqkTZrNmyU12sVHcl9Zxqr7h07aOe+fdqdlq6y8nJ9v2iJRvQ/tkabtx++V+88cp/eeeQ+jR3UX9dOPUejBvRTUlyc1mzcrOKSUllrtXRNijq0bhmgI4FTenTtoh07d2vXnr0qKyvTf+f+pFFDa85sk5GZdeA8k7pO1noVHRWpyy84T7Nfe0kfvvyC/nHLjRp47LEUZwD4xJcRNPs1McbMkpRcfT9r7fFHO1RD53K7NeGc8/TWEw/Ler3qO3KMklq31a8/fidJGji24qbcqcuXqFPP3gpr0rTG/mUlJdq8drUm//Uix7MjMFxutyb95Xy98cRDstarfiPHKqlNWy2ZU9FnBlXeyD1l2RJ17tWnzj6zac0qTaHPNBput1unnXeRXnzoPnmtV4PHHKeWbdtpwfcVc7MPP368JGn1r4vUtXffWn0GjYzXq20fvaYul94kY1xKXzxXxXt3KmF4xUt4+oLv1fqk0xXSLELt/3C+JMl6PUp58i5JkgkNU1TXXtr6wUsBOwQ4yx0SoiuvvV633Xi9vF6vxk+arOSOnfTZ7I8lSVNOO13tk5M1aMhQTbvoAhmX0YTJpyi5Uydt2rhBj9x/n7xer7zWqzHjjtewESMP/wsRFO7443j1S26j6GZN9d71F+jlH35RiLvierBPlqzWwvVbNbRLB7159VSVlJXrwdkV73M8Xqsnv5irh6eeJpcx+nLZGm1Jq/u+aggebrdbl1w5Xffedou8Xq+OHz9R7ZKT9fVnn0qSTp5yitq276D+gwbrhmmXyBiXTpgwSe2TO0qSLr5yup588H6Vl5epRctWuvKGmwN5OHBAiNutay86Xzfe95C8Xq8mHTdWHdu11exvKs4lp40/QXMWLtLsb76T2+1Wk7BQ3XXtlVVTWt3zxDNatmatcvLy9cdp03XhWX/UlOPHBfCI4G9ut1tXn/tn3fzo0/J6vZo4eoQ6tmmtT36YK0m17jtTXc/OHTV2UH9ddvf9crtd6tK+naaMHXXI9ggOIW63rr/8Ml13x93yeL2actIJ6tShvT76ouJei2dMmqgf5s3XR198WXmeCdM/br6Re7sC+J8YX+99YYxZIWmmpF8lefavt9b+eqR9G9sUZ/jfcDM11FfzJmGBjoAGpu17jwQ6AhqY+BsfC3QENDAXzHz3yI2Aap6+4PRAR0ADkpSzO9AR0MB4CvICHQENTJOk1oGOgAYo/pjufKnnR9m7tvMdux/FtG4XkP5bnxE05dbaGX5LAgAAAAAAAAAA0Egc8R401XxqjLnCGNPKGBO3/+G3ZAAAAAAAAAAAAEGqPiNozq/896Zq66ykTkcvDgAAAAAAAAAAQPDzuUBjre3ozyAAAAAAAAAAAACNhc8FGmPMeXWtt9a+dvTiAAAAAAAAAAAABL/6THE2uNrPTSWdIGmpJAo0AAAAAAAAAAD4ifV4Ah0BflCfKc6mV182xkRLev2oJwIAAAAAAAAAAAhyrv9h30JJXY5WEAAAAAAAAAAAgMaiPveg+VSSrVx0S+oh6T/+CAUAAAAAAAAAABDM6nMPmkeq/Vwuaau1dsdRzgMAAAAAAAAAABD0fJ7izFr7o6QUSZGSYiWV+isUAAAAAAAAAABAMPO5QGOMOUvSIkl/knSWpF+MMWf6KxgAAAAAAAAAAECwqs8UZ/8nabC1dp8kGWMSJf1X0vv+CAYAAAAAAAAAABCsfB5BI8m1vzhTKaOe+wMAAAAAAAAAAED1G0HzlTHma0lvVy6fLenLox8JAAAAAAAAAABUsTbQCeAHPhdorLU3GWP+IGmUJCNplrX2I78lAwAAAAAAAAAACFI+F2iMMR0lfWGt/bByOdwYk2yt3eKvcAAAAAAAAAAAAMGoPveQeU+St9qyp3IdAAAAAAAAAAAA6qE+BZoQa23p/oXKn8OOfiQAAAAAAAAAAIDgVp8CTZox5tT9C8aY0ySlH/1IAAAAAAAAAAAAwc3ne9BImibpTWPMM5XLOyRNPfqRAAAAAAAAAAAAgpvPBRpr7UZJw4wxEZKMtTav+nZjzPnW2lePdkAAAAAAAAAAAIBgU58pziRJ1tr8g4szla45CnkAAAAAAAAAAACCXn2mODsScxSfCwAAAAAAAAAASLLWBjoC/KDeI2gOgx4CAAAAAAAAAADgg6NZoGEEDQAAAAAAAAAAgA+OZoFm3lF8LgAAAAAAAAAAgKB1xHvQGGP+aq19wxhzfR2braRMSZ9Ya6866ukAAAAAAAAAAACCkC8jaJpX/htZxyNK0kBJX/olHQAAAAAAAAAAQBA64ggaa+3zlf/ec6g2xph/HM1QAAAAAAAAAAAAwcyXKc6eOtx2a+3V1to7j14kAAAAAAAAAACA4ObLFGe/Vj6aShogaX3lo58kj9+SAQAAAAAAAAAABClfpjh7VZKMMRdIOs5aW1a5PFPSN35NBwAAAAAAAABAI2c9jJUIRr6MoNmvtaTIassRlesAAAAAAAAAAABQD0ccQVPNA5KWGWN+qFweK+nuo54IAAAAAAAAAAAgyPlcoLHWvmyM+VrSVElrJX0laZe/ggEAAAAAAAAAAAQrnws0xphLJF0jqa2k5ZKGSVog6Xi/JAMAAAAAAAAAAAhS9bkHzTWSBkvaaq09TlJ/SWl+SQUAAAAAAAAAABDE6lOgKbbWFkuSMaaJtTZFUjf/xAIAAAAAAAAAAAhePk9xJmmHMSZG0seSvjXGZIl70AAAAAAAAAAAANSbzwUaa+0ZlT/ebYz5QVK0pK/8kgoAAAAAAAAAAFSw3kAngB/UZwRNFWvtj0c7CAAAAAAAAAAAQGNRn3vQAAAAAAAAAAAA4CigQAMAAAAAAAAAAOAwCjQAAAAAAAAAAAAOo0ADAAAAAAAAAADgMAo0AAAAAAAAAAAADqNAAwAAAAAAAAAA4DAKNAAAAAAAAAAAAA4LCXQAAAAAAAAAAABwGNYGOgH8gBE0AAAAAAAAAAAADqNAAwAAAAAAAAAA4DAKNAAAAAAAAAAAAA6jQAMAAAAAAAAAAOAwCjQAAAAAAAAAAAAOo0ADAAAAAAAAAADgMAo0AAAAAAAAAAAADqNAAwAAAAAAAAAA4LCQQAcAAAAAAAAAAACHZq030BHgB4ygAQAAAAAAAAAAcBgFGgAAAAAAAAAAAIdRoAEAAAAAAAAAAHAYBRoAAAAAAAAAAACHUaABAAAAAAAAAABwGAUaAAAAAAAAAAAAh4U48Ut+Tt3ixK9BkCguKwt0BDQwyQlxgY6ABqb3wNGBjoAGJi03P9AR0MA8fcHpgY6ABmb6Kx8HOgIakI8vOy3QEdDAFJWWBDoCGpiQFm0CHQEAGgVG0AAAAAAAAAAAADjMkRE0AAAAAAAAAADg/5PHE+gE8ANG0AAAAAAAAAAAADiMAg0AAAAAAAAAAIDDKNAAAAAAAAAAAAA4jAINAAAAAAAAAACAwyjQAAAAAAAAAAAAOIwCDQAAAAAAAAAAgMMo0AAAAAAAAAAAADiMAg0AAAAAAAAAAIDDQgIdAAAAAAAAAAAAHJq1NtAR4AeMoAEAAAAAAAAAAHAYBRoAAAAAAAAAAACHUaABAAAAAAAAAABwGAUaAAAAAAAAAAAAh1GgAQAAAAAAAAAAcBgFGgAAAAAAAAAAAIdRoAEAAAAAAAAAAHAYBRoAAAAAAAAAAACHhQQ6AAAAAAAAAAAAOAxrA50AfsAIGgAAAAAAAAAAAIdRoAEAAAAAAAAAAHAYBRoAAAAAAAAAAACHUaABAAAAAAAAAABwGAUaAAAAAAAAAAAAh1GgAQAAAAAAAAAAcBgFGgAAAAAAAAAAAIdRoAEAAAAAAAAAAHBYSKADAAAAAAAAAACAQ7MeT6AjwA8YQQMAAAAAAAAAAOAwCjQAAAAAAAAAAAAOo0ADAAAAAAAAAADgMAo0AAAAAAAAAAAADqNAAwAAAAAAAAAA4DAKNAAAAAAAAAAAAA6jQAMAAAAAAAAAAOAwCjQAAAAAAAAAAAAOCwl0AAAAAAAAAAAAcBjWG+gE8ANG0AAAAAAAAAAAADiMAg0AAAAAAAAAAIDDKNAAAAAAAAAAAAA4jAINAAAAAAAAAACAwyjQAAAAAAAAAAAAOIwCDQAAAAAAAAAAgMMo0AAAAAAAAAAAADgsJNABAAAAAAAAAADAoVlrAx0BfsAIGgAAAAAAAAAAAIdRoAEAAAAAAAAAAHAYBRoAAAAAAAAAAACHUaABAAAAAAAAAABwGAUaAAAAAAAAAAAAh1GgAQAAAAAAAAAAcBgFGgAAAAAAAAAAAIdRoAEAAAAAAAAAAHBYSKADAAAAAAAAAACAw7DeQCeAHzCCBgAAAAAAAAAAwGEUaAAAAAAAAAAAABxGgQYAAAAAAAAAAMBhFGgAAAAAAAAAAAAcRoEGAAAAAAAAAADAYRRoAAAAAAAAAAAAHEaBBgAAAAAAAAAAwGEUaAAAAAAAAAAAABwWEugAAAAAAAAAAADg0KzHG+gI8ANG0AAAAAAAAAAAAByGMWaCMSbVGLPBGHNrHdvHGWNyjDHLKx93Huk5GUEDAAAAAAAAAABwCMYYt6RnJZ0kaYekxcaYT6y1aw5q+pO1doqvz0uBxk96tm2ps0b0k8sYzUvZrK9XpNTY3iwsVOeNHayEqAiVezx67cfF2pWV69O+CE592rfSX0YNkstlNHfNBn2+tOb/7WZNwnTx8cOUFBWhMo9H//5+oXZm5ijU7dLfzzhJIW633C6jxRu36eNFvwXoKOCkY1omaEL/HnIZo6WbdujnlE01tjcJDdEfhvZVdPOmchmj+ambtXzzTknStVPGqqTMI2utvNZq1rfzA3EIcNCS9Zv1/Fc/yOu1OnlAb501emid7dbt3KPrX3xLt545RaN6da3XvgguK35dotdfmCGv16txJ03QqX86u1abNb+t0BsvPC9Pebkio6J1+wMPS5K+/PhDzfnmKxlj1DY5WZddc4PCwsKcPgQ4bNniRXp55rPyerw6YeIknXH2ObXarFqxXK/MfE7l5eWKio7WPx55XJJUkJ+vGY8/om1btsgYoyuuv1HdevZy+hDgsJtPO17DuyYru6BIFz73dp1tpk8crWFdOqi4rFwPfPyd1u9OkyQNOaa9rpowWm6X0edL1+itn5c6GR0BsmDRIj32zHPyerw6dfJEnf+XmueZX5cv102336nWLVtJksaNHqVLzp8qScrLz9d9Dz+qTZsrzjO333yj+vTq6fgxwFm/rPhNz7z+tjxeq8njRuvcUyfV2S5l42Zdcfd9unP6NI0bMkiS9P5X3+qzOXMlK00+boz+NOEkJ6MjQBbMn69HH3lEXq9Xp51+us6/4IJabX5dskSPPfaYysvLFRMTo+dnzfJ5XwAN2hBJG6y1myTJGPOOpNMkHVygqRcKNH5gjNE5owboyc9/VFZBkf5+xolauXWXdmfnVrWZ0L+Htmdka+a389UiOlLnjBqgJz7/0ad9EXyMMZo6ZrAe/uR7ZeYX6q4/TdCyzTuqinaSdMrAXtqWnqWnv5yrVjFRmjp2sB6a/Z3KPF49OPs7lZSVy+0yuu0P4/Xb1l3auDcjgEcEfzNGmjSwl16fs0i5RcW69KQRSt21T2m5+VVthhzTXmm5+Xr751/VrEmYpk8crd+27pLHayVJr/7wiwpLywJ1CHCQx+vVc198p/umnqmEqEhd+8KbGtbtGLVPiq/V7qVv52pA5+R674vg4vV49OrMZ3XrP+9XXHyC7rz+ag0cOkxt2neoalOQn69XZjyrm+++VwlJScrJzpYkZWak65tPZ+vB52YprEkTPfXAfVo4d47GnDg+QEcDJ3g8Hr347FO6818PKS4hUbdOv0KDhg1Xuw7JVW0K8vP14jNP6v/ue0CJSS2Uk51Vte2lGc+o36DBuvGOu1VWVqbSkpIAHAWc9tXyFH206DfddsaJdW4f2qWD2sbF6Nyn3lDPti103eSxuuLF9+UyRtdMGqsbX5+ttNx8zbz0LM1L3aytaVl1Pg+Cg8fj0cNPPq2nH35QSYmJumDalRo9YoQ6JXeo0a5fnz567F/31dr/saef1fAhg/XAPXeprKxMxZxngp7H69WTr76pR269QYlxsZp25z81cmA/JbdpXavd8+++r8HH9q5at2n7Dn02Z65m3nO7QkJCdPNDj2t4v2PVtmULpw8DDvJ4PHrowQf1zLPPKqlFC51/3nkaPWaMOnXqVNUmLy9PDz34oJ58+mm1bNlSmZmZPu8L4PfNGHOZpMuqrZplrZ1VbbmNpO3VlndIqusK1uHGmBWSdkm60Vq7+nC/16d70BhjRvqyDhWSE+O0Lydf6XkF8ni9Wrxxm45NrvkGoFVslFJ27pMk7c3JU3xkc0WGN/FpXwSfTknx2puTp7TcfHm8Xv2yfqv6d2xXo03r2Git2bFHkrQ7O1cJkc0VFd5UklRSVi5Jcrtccrtcss7GRwC0iYtRZl6BsgqK5PFardq2W93aJNVoYyU1CXVLksJC3CoqLZPXS+9ojNbt3KPWcTFqFRej0BC3xvTupgWpG2q1+/SXZRrZs4timjer974ILhvXp6pFq1ZKatlKIaGhGjZmrH79ZUGNNvN//EGDh49QQlLFuSc6JqZqm8frUWlpqTwej0pLShQbR0Ev2G1ITVHL1m3UolVrhYaGauS447R4Qc3RmT/98J2GjhytxKSKL7eiY2IlSYUFBVr72286YULFVc2hoaFqHhHh7AEgIFZu3aW8ouJDbh/ZrWPVbAJrduxVRNMmiotopu5tWmhnZo52Z+Wq3OPV96vWa2Q3vgALdmtSUtW2dWu1aV1xnjnp+HGaO2+eT/vmFxRo2crfdOqkiZIqzjORnGeCXsrGTWrTIkmtkxIVGhKi44cN0bxfl9Vq9+E332nM4IGKiYqsWrdt12717NxZTZs0UYjbrX7du+mnJYzUC3arV69W23bt1KZtW4WGhmr8+PGa++OPNdp8/dVXGnfccWrZsqUkKS4uzud9Afy+WWtnWWsHVXvMOqiJqWu3g5aXSupgre0r6WlJHx/p9/pUoKl8Ml/WQVJs83BlFRRWLWcXFCm2eXiNNjsyctS/YxtJFQWduIhmim3ezKd9EXxiI8KVmX/g756VX1jr774tI0sDO1UUbTomxSs+srliIyq+RDXG6B9nT9RTF/1Rq7fv1iZGzwS9qPCmyq32hUZuYXFVwW6/Reu3KiEyQjecepyuOHmUvly2tupVw1pp6rjBuuykEVX9CsErIzdfCdU+cCZERSqj2mgrSUrPzdP8lA2aNKhvvfdF8MnKyFBcQmLVclx8grIyar627Nm1UwX5+br37zfp9muv0k/f/7eq7aQzztQ1F03VVef9Rc2aN1efAQMdzQ/nZWakKyHxQJ+JT0hUZnp6jTa7d+xQfn6e7rzpet185TTN+fYbSdLePbsVFR2tZx99SDde8TfNePwRFRcXOZofv0+JURE1Rgen5eYrMSpCiVHNlZabd9D65oGICAftS09Xi6QDFyQlJSYqLb32557f1qzRuRdfpmtv+bs2bd4iSdq1e7diY6L1zwcf1tRL/6b7Hn5URUWcZ4JdWla2Eiu/PJekxLhYpWVl12yTmaWflyzVqSeMq7G+Y9s2Wpm6Tjl5+SouKdHCFSu1LyPTgdQIpLR9+9SixYFRUklJSUrbt69Gm23btikvL0/TLrtM5/31r/r8s8983hdAg7dDUvUv0dqqYpRMFWttrrU2v/LnLySFGmMSDvekh53izBgzXNIISYnGmOurbYqS5D7CvlVDgkafe6l6jql72HpjYQ+qpX29fK3OGtFf//eHk7QzK0fb07Pl8Xp92hfBx9RZgK3p819X69zRg/SPsydqR0aOtqZlyVvZZ6y1uvPdL9UsLFTTJ45Rm7ho7czM8Xds/M7Yg4r2x7RM1J7sXL06Z5HiIppp6tjBmvn1PJWUl+ul7xYqr7hEzZuEaeq4wUrPy2dakCB2cN+QKqbJq27WV3N00Ymj5XbVvHbDl30RfGxdbz4O+sN7PR5t3rhBf7/3AZWVlOjum67TMd26Kyo6Wkt/WaDHX3xFzZpH6OkH7tPPP3ynUced4FB6BELdXaZmn/F4PNq0fr3uevBhlZaU6rZrp6trjx4V6zes10VXTlfX7j300oxn9NG77+ic8y90KD0akjrPT+IzU6NQxx/54Pck3bp00ex33lKz8HDNW/iLbrrjLn3wxqvyeDxKXbdeN0y/Sr179tCjTz+rV99+R9Mu4jwT1OrqMwctP/PG27rsz2fWeg/coU1rnTNlom584FGFN22izu3bye0+7NdgCAJ1vpQc/H6mvFwpa9fq2RkzVFJSoosvvFC9+/TxaV8ADd5iSV2MMR0l7ZT0Z0l/qd7AGNNS0l5rrTXGDFHFAJnDXkl/pHvQhEmKqGwXWW19rqQzD7dj5RCgWZI0bdZ/GtXb5ayCIsVWmx4mpnm4sgtrXp1TXFau135cXLV83zmTlZFXoLCQkCPui+CTmV+ouIgDf/fYiGbKKqjdZ/79/cKq5UemnlbjikJJKiwtU8quferTvjUFmiCXW1RzxExUs6bKK6o5j3a/jm3089pNkir6WHZBkRKimmtnZo7yiivaFpSUKmXHXrWJi6FAE8QSoiKVXu1K4/TcPMVF1pzWY/2uPXrg/c8lSbmFRVq8fpNcLuPTvgg+cQkJykxPq1rOzEhXbLUrUCUpNj5Bx0ZFqWnTpmratKm69+6tbZsrzjmJLVooKjpGkjRoxEitX7uWAk2Qi09IUHragT6TkZ6m2PiaU9vFJyYqMjpaTZuGq2nTcPXs00dbNm1Sj959FJ+YqK7de0iSho0ao4//846j+fH7tH/EzH6JURFKzytQiNutxGqjO/evR3BLSkzU3mpXo+9LS1PCQeeZiOYHRlKNHDZUDz/xlLJzcpSUmKikxET17llxnjl+7Bi99tbbzgRHwCTGxSot88Col7TMLCXExtRok7p5q/7xzPOSpJy8fP2y4je5XS6NHjRAk8eN1uRxoyVJL7z7gRLjYh3LjsBISkrS3r17q5b37dunxGojhCUpqUULRcfEKDw8XOHh4erXv7/Wr1/v074AGjZrbbkx5ipJX6ti8MpL1trVxphpldtnqqJmcrkxplxSkaQ/20NdYVTpsFOcWWt/tNbeI2mYtfaeao/HrLXrj8aBBaOtaZlKio5QfGRzuV0uDe7cXiu31hjtpPCw0KorNEZ176T1u9NUXFbu074IPpv3ZahFdKQSKv/uQ7t00LItO2q0aVatz4zt2Vmpu/apuKxckU2bqFlYqCQp1O1Wz7YttTsr1/FjgLN2ZeYoPrK5YpqHy+0y6t2+lVJ31hw+nVNYrE4tKj60Nm8SpvjI5srKL1So262wkIqrv0LdbnVumaB9OXm1fgeCR9fWLbUrI1t7snJUVu7R3FWpGtatc402L197qV65ruIxqmdXXTn5RI3o0cWnfRF8OnXppj27dmnfnj0qLyvTwrk/asCQYTXaDBw2XKmrV8vj8aikuFgbU1PVul17xScmaUNKikqKi2Wt1eoVy9WmHVMpBrtjunXX7p07tXfPbpWVlWnenB80eNiIGm0GDx+htat+q+oz61NS1LZ9e8XGxSk+IVE7t1fcb/O35cvUtn2Hun4NGpn5qZt1ct/ukqSebVuooKRUmfmFSt21V23jo9UyJlIhbpeO791F81M3Bzgt/K1H927avnOndu2uOM98+/0cjRlR8zyTkZlZNcpq9doUea1X0VFRio+LU1JSorZuqzjPLFm6VB2TOc8Eu26dOmrHnr3avS9NZeXl+n7hIo0Y0K9Gm3cef1DvPvGQ3n3iIY0dMlDXXvBXjR40QJKUlVPxuXpveobmLlmqE0bUdR9oBJOePXtq+/bt2rlzp8rKyvTNN99o9JgxNdqMGTtWy5cvV3l5uYqLi7V61Sp1TE72aV/gf2a9PPz58OVPYO0X1tqu1trO1tr7KtfNrCzOyFr7jLW2l7W2r7V2mLV2/uGf8cgjaPZrYoyZJSm5+j7W2uN93L9R8Vqrd+ct1dUTx8jlMpqfulm7s3I1ukfFF1o/rd2oljFRuvC4IfJaq91ZuXq9cjTNofZFcPNaqzd+WqIbTz1eLmP009qN2pWZo+N6dZEk/bB6vVrFRuvSE4fLWqudmTl66YdfJEnRzcN16QnD5TJGxhgt2rBVK7buDOThwAFea/XF0jWaOnawjDFatmmH0nLzNahzxZegSzZu19zVG3T60GN1+cmjZIz035WpKiwtU2zzcJ09quJDh8sY/bZ1tzbsST/cr0MD53a7dPmk43X76x/Ia70a37+3OiQl6PPFKyRJkwf3rfe+CG5ut1vnT7tCD931f/J6vRp74ni17ZCs776sGGV1wsTJatOuvY4dOFB/n365XMZo3PgJatchWZI0ZORo3X7tVXK73erQqbOOmzAxgEcDJ7jdbl1y5XTde9st8nq9On78RLVLTtbXn30qSTp5yilq276D+g8arBumXSJjXDphwiS1T+4oSbr4yul68sH7VV5ephYtW+nKG24O5OHAIXf8cbz6JbdRdLOmeu/6C/TyD78oxF1xQdInS1Zr4fqtGtqlg968eqpKysr14OzvJEker9WTX8zVw1NPk8sYfblsjbakcW+IYBfiduvGq6fr6ptvldfr1SkTJ6hTx2R9+EnFeeYPp56i73+cqw9mfyq3260mTcJ07x23V023eOPVV+nO+/6l8vIytW7VSnfcclMgDwcOCHG7dc355+qmhx6X1+vVxLGj1LFtG83+bo4k6bSD7jtzsDuffE65+fkKCXHr2vPPVWRz7nUV7EJCQnTTTTfp6unT5fV4dMqpp6pz58764P33JUl/PPNMdezYUcOHD9e555wjY4xOO/10dT7mGEmqc18AOBJzhBE2FY2MWSFppqRfJXn2r7fW/urLL2lsU5zhf1NcVhboCGhgkhPijtwIqGaqd3ugI6CByRx4UqAjoIFpWjm6FfDV9Fc+DnQENCAfX3ZaoCOggSnauTXQEdDANOt+6Iu4gEOJjozkxjt+tGfJPL5j96OWg0YGpP/6OoKm3Fo7w69JAAAAAAAAAAAAGonD3oOmmk+NMVcYY1oZY+L2P/yaDAAAAAAAAAAAIEj5OoLm/Mp/q0/SaiV1OrpxAAAAAAAAAAAAgt//Y+++4+Sq6v6Bf052QxFI3wRCS1B6ld5BUAQBsWJHsCAqYAPlQUTsNEEUAVEfey+IKI8NVBCkd0IC0nsaSUgIJNm5vz92SE/Y9Ze9Qzbv9+u1r8y9c+7Md7JnZ+7czz3ndiugqapqdG8XAgAAAAAAsKLoVkBTSjlsceurqvrhsi0HAAAAAACg7+vuFGc7zHd7lST7JrkpiYAGAAAAAACgh7o7xdkx8y+XUgYm+VGvVAQAAAAAAMxVVVWrS6AX9Psvt3smyYbLshAAAAAAAIAVRXevQXNJkucjurYkmyb5ZW8VBQAAAAAA0Jd19xo0Z853e06SB6uqeqQX6gEAAAAAAOjzujXFWVVV/0wyNskaSQYnmdWbRQEAAAAAAPRl3QpoSimHJrkuyZuTHJrk2lLKm3qzMAAAAAAAgL6qu1OcfTrJDlVVjU+SUkpHkr8l+XVvFQYAAAAAANBXdWsETZJ+z4czTZN6sC0AAAAAAADz6e4Imj+VUv6c5GfN5bck+b/eKQkAAAAAAKBv61ZAU1XV8aWUNyTZPUlJcmFVVRf1amUAAAAAAEDS2dnqCugF3QpoSimjk1xaVdVvm8urllJGVVX1QG8WBwAAAAAA0Bd19zoyv0rSmG+5s7kOAAAAAACAHupuQNNeVdWs5xeat1fqnZIAAAAAAAD6tu4GNBNKKa99fqGUckiSib1TEgAAAAAAQN/WrWvQJDkqyU9KKec2lx9J8q7eKQkAAAAAAKBv61ZAU1XVvUl2LqWsnqRUVfX0/PeXUt5dVdUPeqNAAAAAAACAvqa7U5wlSaqqmr5wONP0kWVUDwAAAAAAQJ/Xo4BmKcoyehwAAAAAAIA+r7vXoHkh1TJ6HAAAAAAAYD5V1Wh1CfQCI2gAAAAAAABqtqwCmquW0eMAAAAAAAD0ed0KaEopQ0sp3yil3FRKubGUck4pZejz91dVdXTvlQgAAAAAANC3dHcEzc+TjE/yxiRvSjIhyS96qygAAAAAAIC+rL2b7YZUVfWF+Za/WEp5XS/UAwAAAAAA0Od1dwTN30spby2l9Gv+HJrkj71ZGAAAAAAAQF+11BE0pZSnk1RJSpKPJ/lR8662JNOTfLZXqwMAAAAAAOiDlhrQVFW1RimlJFm3qqqHaqoJAAAAAACgT3vBa9BUVVWVUi5Ksl0N9QAAAAAAAPOrqlZXQC/o7jVoriml7NCrlQAAAAAAAKwgXnAETdMrkhxVSnkgyYx0XZOmqqpqq94qDAAAAAAAoK/qbkBzQK9WAQAAAAAAsALp1hRnVVU9mGTdJPs0bz/T3W0BAAAAAABYULdCllLKZ5N8Ksn/NFf1T/Lj3ioKAAAAAACgL+vuKJjXJ3ltuq4/k6qqHkuyRm8VBQAAAAAA0Jd1N6CZVVVVlaRKklLKar1XEgAAAAAAQN/W3s12vyylfCvJoFLK+5O8J8m3e68sAAAAAAAgSVI1Wl0BvaC7AU0jyZVJpiXZKMnJVVX9tdeqAgAAAAAA6MO6G9CskeS9SSYn+XmS23qtIgAAAAAAgD6uW9egqarqc1VVbZ7kw0lGJvlnKeVvvVoZAAAAAABAH9WtgGY+45M8kWRSkuHLvhwAAAAAAIC+r1sBTSnlg6WUfyS5LMmwJO+vqmqr3iwMAAAAAACgr+ruNWjWT/LRqqpu6cVaAAAAAAAAVgjdCmiqqjqhtwsBAAAAAABYUfT0GjQAAAAAAAD8f+ruFGcAAAAAAEALVJ2NVpdALzCCBgAAAAAAoGYCGgAAAAAAgJoJaAAAAAAAAGomoAEAAAAAAKiZgAYAAAAAAKBmAhoAAAAAAICaCWgAAAAAAABqJqABAAAAAACoWXurCwAAAAAAAJasqhqtLoFeYAQNAAAAAABAzQQ0AAAAAAAANRPQAAAAAAAA1ExAAwAAAAAAUDMBDQAAAAAAQM3a63iSD++3ax1PQx+xUltbq0tgOdOoqlaXwHLm8eO+2OoSWM6sP2xEq0tgObPS8JGtLoHlzO+OPKTVJbAced2FF7e6BJYzP9hheKtLYDkza8LjrS6B5dDA17y51SXAcscIGgAAAAAAgJoJaAAAAAAAAGpWyxRnAAAAAADAf8kU/32SETQAAAAAAAA1E9AAAAAAAADUTEADAAAAAABQMwENAAAAAABAzQQ0AAAAAAAANRPQAAAAAAAA1ExAAwAAAAAAUDMBDQAAAAAAQM3aW10AAAAAAACwZFVnZ6tLoBcYQQMAAAAAAFAzAQ0AAAAAAEDNBDQAAAAAAAA1E9AAAAAAAADUTEADAAAAAABQMwENAAAAAABAzQQ0AAAAAAAANRPQAAAAAAAA1Ky91QUAAAAAAABLUTVaXQG9wAgaAAAAAACAmgloAAAAAAAAaiagAQAAAAAAqJmABgAAAAAAoGYCGgAAAAAAgJoJaAAAAAAAAGomoAEAAAAAAKiZgAYAAAAAAKBm7a0uAAAAAAAAWIqqanUF9AIjaAAAAAAAAGomoAEAAAAAAKiZgAYAAAAAAKBmAhoAAAAAAICaCWgAAAAAAABqJqABAAAAAAComYAGAAAAAACgZu2tLgAAAAAAAFiyqqpaXQK9wAgaAAAAAACAmgloAAAAAAAAaiagAQAAAAAAqJmABgAAAAAAoGYCGgAAAAAAgJoJaAAAAAAAAGomoAEAAAAAAKiZgAYAAAAAAKBm7a0uAAAAAAAAWLKqs7PVJdALjKABAAAAAAComYAGAAAAAACgZgIaAAAAAACAmgloAAAAAAAAaiagAQAAAAAAqJmABgAAAAAAoGYCGgAAAAAAgJoJaAAAAAAAAGrW3uoCAAAAAACApagara6AXmAEDQAAAAAAQM0ENAAAAAAAADUT0AAAAAAAANRMQAMAAAAAAFAzAQ0AAAAAAEDNBDQAAAAAAAA1E9AAAAAAAADUTEADAAAAAABQs/ZWFwAAAAAAACxFVbW6AnqBgKaX3Hz9dfneBd9Mo7ORfQ94TV7/lrct0uaOW2/J9y84L3PmzMmAgQPz+TPPTpLMmD495599Zh564IGUUvKhjx+XjTfbvO6XQM1uvO7afOe8c9PZ6Mx+BxyYN73tHYu0uf2Wm/Od88/NnDmdGTBwYL5y1jlJkve94y1ZddWXpF9bv7S1teWs8y6su3xa4Kbrr8t3zjs3jUZnXnXAgXnjW9++SJvbb70l3z3v3HR2zsmAAQPzpWafef8739rVZ/p19ZmvnvetusunZoO23ikbHPHRlH798uRll+SRi3+8wP2rjlwvG37o01l99EZ58OcX5tFLfjb3vpEHvDkj9n1tUkqevOz3eezSX9ZdPi1w3ZhxOe/XF6fRqHLArjvmbfu9YrHtxj74cI4989yc9J53ZM+Xb5UkecfJX8mqK6+ctn4lbf365bxPfaTO0mmRa2+5NV//3o/SaDRy4L57552ve+0C999855icePrZWWt4R5Jkz512yOFven2S5NTzLszVN92SwQMH5AdfPbX22mmNf193Xc4697w0Oht57YEH5N1vX/A704233JLjTzo5I9dcK0my9x67533vfleS5Onp0/OlM76a++7v+s500iePy5abb1b7a6A+nzxkn+yy0ahMmTEzR5z3s8W2OeaAPbLzhuvn2dlzcurvLss9j09Ikuz4svVy9P57pK1fyR9vGpOf/uumOkunha6/656c/7s/ptGosv/O2+Wt++652HbjHnokHznnwpx42KHZc+st5q7vbDRy9NnnZ9jAAfnC+95VV9m00PV33Z3zL7o0jaqR/XfaLm995V6LbTfuoUfyka99Kyce9pbsuc1CfeasZp95vz4DvDABTS/o7OzMd7759Zz8ldMzZFhHTjjmQ9l+512y7vqj5raZMX16vnPuOfn0l05Nx/ARmTrlqbn3/e/552ab7XfIcZ85JbNnz86s555rwaugTp2dnfnWN87J5087M0M7OvKJDx+VHXfdLevN12emT386F3z9aznlK6enY8SITHnqqQUe40tfPTsDBg6qt3Ba5vk+87nTzsjQYR05/uijsuMuuy7wPjN9+vR86+tfy2e/clo6hi/aZ7545tkZMHBgzZXTEqVfXvreT+SOL340syaNzzZf+U4m3fCvzHz0gblN5kyflvu+d3aG7rDgl9aXrDs6I/Z9bW498X1pzJmTLU78aibfdHWefeKRml8EdepsNPKNX16U045+fzoGDcyHz/hGdt1ys6y/1ohF2n3n4kuz/aYbLfIYX/3IBzJw9dXqKpkW62w0cvZ3f5CzTjohHUOH5Mj/OTm7b79dRq2z9gLtttp045x2wnGLbL//3nvm9fu/Kl/+phMGVhSdnZ0545xv5BtnnJbhHR05/KgPZ49dd80Go9ZfoN02W26Zs77ypUW2P+sb38wuO+6QUz/32cyePTvP+s7U5/3plrG56Lrbc+LrX7nY+3facP2sM2RQ3vH1H2ezdUbkYwfulQ9959fpV0o+8pq9ctyPLs6EadNzwfsPzVXj7s+DE55a7OPQd3Q2Gjn3t5fk1KMOz7CBA3LM2Rdkl803yfprDl+k3Xf+8Jdst/HLFnmMi674d9Yb3pFnvMesEDobjZz7m0ty6lFHZNigZp/ZYtPF95lL/pztNtlwkce46Ip/Z70RHXnmWX0G6B7XoOkF/xk3NmuOXDsj1hqZ/v37Z7e9X5Hr/331Am2u/Ptl2Wm3PdIxvOtAx8BBg5Mkz8yYkbtuvz377v+aJEn//v2z2uqr1/sCqN0948ZmrZFrZ82RXX1mj733ybVXXbVAmysuuyy77L5HOkZ09ZlBgwe3olReJLr6zMis2Xyf2X3vfXLt1Qv1mcv/1tVnhuszK7o1XrZpnn3ikTw3/rFUnXMy4erLMnSHPRZoM3valEy/d2yqzjkLrF917VF5+p4705j1XNLozNS7bsnQHRd/5iF9x7gHHs7IYcMyctjQ9G9vz97bbp2rbrtzkXa/++dV2WPrLTNoDfsqK7q7/nNv1l5zREaOGJ7+7e3Zd9ed86/rb+z29ttstkkG2OddoYwZOy7rjByZtZv7v6/aZ+9csdD+75JMnzEjN992e177mgOSdH1nWkP/6fNue/CxPD3z2SXev9vGo/PnW8cmScY88mRWX2XlDFn9Jdlk7RF5dPLUPP7UtMzpbOTyO+7JbhtvUFfZtNC4hx7JyGFDs9bQIenf3p69Xr5lrr7jrkXaXXzlNdljq80X2Z+ZMGVqrrvr7uy/8/Z1lUyLze0zw7rRZ7bePIMWOhlpwpSpuW7MuOy/83Z1lQz0Ad0OaEopu3VnHcnkSRMzrKNj7vLQYR2ZPHHiAm0ef+SRTJ/+dE4+/uP55IePyj/++pckyZNPPJ4BAwfmm189Pcd96AM5/+wz8+yzM2utn/pNmjghw4bP6zPDOjoyadKEBdo8+ujDmT59ek78+EfysQ8emcv/8ud5d5aSkz91fD72wSPzpz9cUlfZtNDkiRMzrGPeWTyLe5957JFHMv3pp/PpT3w0H//Qkfn7X+f1mVJKTjnh+Hz8Q0fmz3/UZ/q6lYZ05LlJ4+cuPzdpfFYa0rGULeZ55uH7MnDTrdO++oD0W2nlDH75Lll56IgX3pDl2sSpUzN88LwRdh2DB2bS1GkLtpkyNVfdekcO2mPnRbYvJfnUud/OB087J3/41zW9Xi+tN3HyUxk+dMjc5Y6hQzJh8qJnp995939yxPEn5vgvn577HzYSb0U2fuLEjBg+b19meEdHJkyctEi728eMyTvee2Q++qn/yX33P5AkeezxxzN40MB84bQz8q73fyBfOuOrmTnTd6YVXceA1TNh2vS5yxOmTU/HgNXTMWC1TJj29ELrjfBcEUycOi0dg+bbnxk0MJOmPr1gmynTctXtd+XAXXdYZPvzf3dp3nfQfulXSq/XyovDxCkL9ZmBAxazDzwtV90+JgfuuuMi259/0aV538Gv1meAHunJFGffSLJtN9at8BZ3vaay0JtzZ2dn7rvnnnz2tDMy67lZOfGjx2SjTTftWv+fe/KeDx+TjTbZNP97/rm56Bc/z9vefURN1dMKi+0zWbTP/OfucfniGWdl1qzncvyxH87Gm22WtddZN6d97dwMHTYsU556Kid/6riss9562WKrrWuqnlaoFv9Gs8Bio7Mz995zdz5/+lcza9asfOrYD2ejTbv6zKlnfyNDmn3mlBOOyzrrrpfN9Zm+a3FfELp5ccGZjz6YRy7+SbY46WvpfHZmZjz4n1SNzmVcIC823eke5/3m93nfIa9JW79Fz/f52sc+lGGDBuapp6fnU+d+O+utOTxbvczZyn3Z4j6XFn7r2Wj0qPzyvK/lJauskn/fdEtOPOPs/OzrX62pQl50utFnNt5ww1z885/mJauumquuuTbHf+az+c2Pf5DOzs6Mu/uefOKYo7PFZpvmq9/4Zn7ws5/nqPf4zsSCFrvPHNdYXmG88FemnH9xVwiz8P7MNXeOy6DVV89G666dW/9zfy8WyYvdwsdmzv/dH/O+g169mD4zNoPWWK3ZZ+6rs0RgOfeCAU0pZZckuybpKKV8fL67BiRpW8p2RyY5MklO/tKpedPbF73geV81dNiwTJwwb/TDpIkTMnjo0AXbdHRkjYEDs8oqq2aVVVbNZltumQfuuy+bbrFlhnZ0ZKNNNk2S7Lz7nvndL39ea/3Ub1hHRyaOn9dnJk6YkCFDhy3YZlhHBgwYmFVWXTWrrLpqNt9y69x/771Ze511M3RYV9tBgwdn5912zz1j7xLQ9HFDOzoyccK8ERGTJk7IkCW9zzT7zGZbbZUHmn1myHx9Zqfd9sg948YKaPqwWZPGZ+Wh885SXnno8Mx6auJStljQk3//Q578+x+SJOu/7QMLjMahb+oYNDDjn5o6d3nCU1MzdOCABdrc/dAj+dL3fpokmTp9Rq67c2za+vXLbltvkWHNMw8Hr7F6dttq84x94GEBTR/XMXRIxk+aPHd5wqTJGbbQ1JqrveQlc2/vsu02Ofu738+UaU9n0IA1aquTF4/hHR15cvy8z5PxEyZk2EL7MquvNm+Uw24775Qzvvb1TJk6NcM7OjK8oyNbbNb1nWmfvfbMD3+6+IvGs+J4fsTM8zoGrJ6JT89Ie1tbOuZ7n3l+PX3fsEEDMmHKfPszU6ZmyEKfOXc//Gi+/KNfJkmmzngm1911d9r69cvYBx/JNXeOzfV33Z1Zc+bkmWefy6k//lVOeOeba30N1GuRPjN1WoYMXEyf+eEvkszXZ9qafeaOsbl+jD4D9Ex3pjhbKcnq6Qpz1pjvZ1qSNy1po6qqLqyqavuqqrZfkcKZJHnZxpvk8UcfzZNPPJ7Zs2fnqn/8PTvsvOsCbXbYZdfcdcft6ezszHPPPpt7xo7NOuutl8FDhmTosI48+vDDSZLbb7k566y3/uKehj5kw403zmOPPpInHu/qM1f+4/LstOuCfWanXXfPmDtuT2fnnDz37LO5e+yYrLveenl25sw888wzSZJnZ87MLTfekPVGjW7Fy6BGGz7/PtPsM//6x+XZcZcF+8yOu+yWMbffNt/7zF1ZZ7318+zMmZmpz6xQnr53bFZda52s3LFWSlt7OnbdN5Nv+Fe3t+8/YFCSZOWhIzJ0x70y4aq/9VKlvFhsvP46eXTCxDw+cXJmz5mTf9x0a3bdarMF2vz4c/+Tn3y+62fPl2+ZY9/y+uy29RaZ+dysPPNs1zUCZj43KzeOvSejRq7ZipdBjTZ56QZ55PEn8tj48Zk9Z04uu/qa7Lb9ggPtJ02ZMvds9jH/uTeNRpWBrl+0wtp0k43z8KOP5rHmvsxfL/9H9lxo/3fS5Mlz+8ydd41No2pk4IABGTpkSIYP78iDD3V9Z7rhppsyepTvTCu6q8fdn1dvvUmSZLN1RmTGc7MyefozGffYk1ln6MCsOWiNtLf1yz5bbJirxxkRsSLYeN218+iESXl80lOZPWdO/nnz7dlli00WaPOjkz6RH32m62ePrTfPMW88KLttuVnee9B++elnj8+PPvOJnPiuQ7PNhqMdaF8BzOszk+f1mc0X6jOfOS4/Ornrp6vPHDyvz5zyyfzo5ONy4mGHZpsNN9BngG55wRE0VVX9M8k/Synfr6rqwRpqWu61tbXlfR8+Jl888VNpNBrZZ78Dsu6oUflz89ogrz7o4Kyz3vp5+fY75BNHvS+l9Mu++79m7gHS9374mJxz2pczZ87sjFhzrXz4E59s5cuhBm1t7fnAMR/JKSccn0ajkVfuf0DWGzU6/3fJxUmSAw4+JOuuv3623X7HHPv+96b0K3nVAQdm/dEb5InHHsuXT/lMkq5p0PbaZ99st+NOrXw51KCtrS3vP/rYfO5/PpnORiOvfHVXn/nTJb9Pkux/8Gu7+swOO+YjR743/fqVvPKAA7P+6NF54vHHcup8fWbPV7wy2+6w6Py59CGNztz7v2dni0+flfRry5N//0OeeeT+rPmq1yVJnvjr79J/4JBsc+p307bqaknVyMjXHJqbPv6OdM58Jpt84svpv8aAVHPm5N7vfjWdM55e+vOx3Gtra8sxhx6SE775nTSqRvbfeYeMWmvNXHLlv5MkB++xyxK3ferpp3PKt3+YJOnsbGSf7bfJjpttXEvdtE57W1s++p5357gvnZ5Go5HXvGKvjF53nVz8l8uSJIfst2/+cc11ufgvl6WtrS0rr9Q/n/3oh+dOA/y5r52bm8fclalPT88bjzomRxz6xhy0z94tfEX0tva2thx37DE59pMnpNFo5OAD9s8Go0flt7/v+s70htcenMv/eUV+c/ElXX1m5ZXyxc+cNLfPHHfs0Tn5S1/JnDmzM3KttfKZTx3fypdDDT7zxv2yzai1M/Alq+RXHz883/v7tWlv6zrn9Pc33Jlr7nkwO224fn5y7Lvy3Ow5Oe3irvefzkaVcy69Ime865D0KyX/d/OYPDBh8tKeij6ira0tR7/hoJx44Q/SaDTy6h23zag1R+QPV1+XJDloMdcQYcXW1taWo994UE78VrPP7LRdRq01In+4qtlndtNngGWvLGlO1kUalrJRkuOSjMp8wU5VVfu80La3P/CIGV7ptpXaljhzHixWwyTS9NCk45zJRM+s/34nS9AzKw0f2eoSWM6s3GGkGd33ugsvbnUJLGd+sMPwF24E83Ohe/4L67/mzTpOL3rg9z9zAKwXjXrt21rSf19wBM18fpXkgiTfSeLqwAAAAAAAAP+lngQ0c6qqOr/XKgEAAAAAAFhB9OtB20tKKR8qpaxVShny/E+vVQYAAAAAANBH9WQEzbub/85/9cUqyQbLrhwAAAAAAIC+r9sBTVVVo3uzEAAAAAAAgBVFtwOaUsphi1tfVdUPl105AAAAAAAAfV9PpjjbYb7bqyTZN8lNSQQ0AAAAAAAAPdCTKc6OmX+5lDIwyY+WeUUAAAAAAAB9XE9G0CzsmSQbLqtCAAAAAACAxaiqVldAL+jJNWguSfJ8L2hLsmmSX/ZGUQAAAAAAAH1ZT0bQnDnf7TlJHqyq6pFlXA8AAAAAAECf16+7Dauq+meSsUnWSDI4yazeKgoAAAAAAKAv63ZAU0o5NMl1Sd6c5NAk15ZS3tRbhQEAAAAAAPRVPZni7NNJdqiqanySlFI6kvwtya97ozAAAAAAAIC+qtsjaJL0ez6caZrUw+0BAAAAAABIz0bQ/KmU8uckP2suvyXJ/y37kgAAAAAAAPq2bgc0VVUdX0p5Q5Ldk5QkF1ZVdVGvVQYAAAAAANBHdTugKaWMTnJpVVW/bS6vWkoZVVXVA71VHAAAAAAArOiqqtHqEugFPbmGzK+SzN8LOpvrAAAAAAAA6IGeBDTtVVXNen6heXulZV8SAAAAAABA39aTgGZCKeW1zy+UUg5JMnHZlwQAAAAAANC3dfsaNEmOSvKTUsq5zeVHkrxr2ZcEAAAAAADQt3U7oKmq6t4kO5dSVk9Sqqp6ev77SynvrqrqB8u6QAAAAAAAgL6mJ1OcJUmqqpq+cDjT9JFlUA8AAAAAAECf1+OAZinKMnwsAAAAAACAPmtZBjTVMnwsAAAAAACAPqvb16DpBiNoAAAAAABgWauMj+iLuj2CppTS9gJNrvr/rAUAAAAAAGCF0JMpzu4vpVxYStm3lLLIaJmqqo5ehnUBAAAAAAD0WT0JaDZO8rckH05XWHNuKWX33ikLAAAAAACg7+p2QFNV1cyqqn5ZVdUbkrw8yYAk/+y1ygAAAAAAAPqonoygSSllr1LKeUluSrJKkkN7pSoAAAAAAIA+rL27DUsp9ye5JckvkxxfVdWM3ioKAAAAAACgL+t2QJNk66qqpvVaJQAAAAAAACuIFwxoSinfSFI1by9yf1VVxy77sgAAAAAAgCSpOjtbXQK9oDvXoLkhyY3puubMtknuaf5sk0SvAAAAAAAA6KEXHEFTVdUPkqSUcniSV1RVNbu5fEGSv/RqdQAAAAAAAH1Qd0bQPG9kkjXmW169uQ4AAAAAAIAeeMERNPM5NcnNpZS/N5f3SnLKMq8IAAAAAACgj+t2QFNV1fdKKX9O8q4kdyX5U5LHeqswAAAAAACAvqrbAU0p5X1JPpJknSS3JNk5yb+T7NMrlQEAAAAAAPRRPbkGzUeS7JDkwaqqXpHk5Ukm9EpVAAAAAAAAfVhPAppnq6p6NklKKStXVTU2yca9UxYAAAAAAEDf1e0pzpI8UkoZlOR3Sf5aSnkqrkEDAAAAAAC9q2q0ugJ6QbcDmqqqXt+8eUop5e9JBib5U69UBQAAAAAA0If1ZATNXFVV/XNZFwIAAAAAALCi6Mk1aAAAAAAAAFgGBDQAAAAAAAA1E9AAAAAAAADUTEADAAAAAABQMwENAAAAAABAzQQ0AAAAAAAANWtvdQEAAAAAAMCSVVXV6hLoBUbQAAAAAAAA1ExAAwAAAAAAUDMBDQAAAAAAQM0ENAAAAAAAADUT0AAAAAAAANRMQAMAAAAAAFAzAQ0AAAAAAEDNBDQAAAAAAAA1a291AQAAAAAAwFJ0dra6AnqBETQAAAAAAAA1E9AAAAAAAADUTEADAAAAAABQMwENAAAAAABAzdrreJJ12ubU8TT0EaW/3JCe6XxmRqtLYDkzub2Wjz/6kM6Zz7S6BJYznTOebnUJLGdmznqu1SWwHPnBDsNbXQLLmXdfP77VJbCcOb9jSqtLAFghOBIOAAAAAABQMwENAAAAAADAUpRS9i+ljCul/KeUcsJS2u1QSukspbzphR5TQAMAAAAAALAEpZS2JN9MckCSzZK8rZSy2RLanZbkz915XJPwAwAAAADAi1hVVa0uYUW3Y5L/VFV1X5KUUn6e5JAkYxZqd0yS3yTZoTsPagQNAAAAAACwwiqlHFlKuWG+nyMXarJ2kofnW36kuW7+x1g7yeuTXNDd5zWCBgAAAAAAWGFVVXVhkguX0qQsbrOFlr+W5FNVVXWWsrjmixLQAAAAAAAALNkjSdadb3mdJI8t1Gb7JD9vhjPDkrymlDKnqqrfLelBBTQAAAAAAABLdn2SDUspo5M8muStSd4+f4OqqkY/f7uU8v0kf1haOJMIaAAAAAAAAJaoqqo5pZSjk/w5SVuS/62q6s5SylHN+7t93Zn5CWgAAAAAAACWoqqqS5NcutC6xQYzVVUd3p3H7Pf/XxYAAAAAAAA9IaABAAAAAAComSnOAAAAAADgxaxqtLoCeoERNAAAAAAAADUT0AAAAAAAANRMQAMAAAAAAFAzAQ0AAAAAAEDNBDQAAAAAAAA1E9AAAAAAAADUTEADAAAAAABQMwENAAAAAABAzdpbXQAAAAAAALBkVaPR6hLoBUbQAAAAAAAA1ExAAwAAAAAAUDMBDQAAAAAAQM0ENAAAAAAAADUT0AAAAAAAANRMQAMAAAAAAFAzAQ0AAAAAAEDNBDQAAAAAAAA1a291AQAAAAAAwFI0OltdAb3ACBoAAAAAAICaCWgAAAAAAABqJqABAAAAAAComYAGAAAAAACgZgIaAAAAAACAmgloAAAAAAAAaiagAQAAAAAAqFl7qwsAAAAAAACWrKqqVpdALzCCBgAAAAAAoGYCGgAAAAAAgJoJaAAAAAAAAGomoAEAAAAAAKiZgAYAAAAAAKBmAhoAAAAAAICaCWgAAAAAAABqJqABAAAAAACoWXurCwAAAAAAAJai0Wh1BfQCI2gAAAAAAABqJqABAAAAAAComYAGAAAAAACgZgIaAAAAAACAmgloAAAAAAAAaiagAQAAAAAAqJmABgAAAAAAoGYCGgAAAAAAgJq1t7oAAAAAAABgyapGZ6tLoBcYQQMAAAAAAFAzAQ0AAAAAAEDNBDQAAAAAAAA1E9AAAAAAAADUTEADAAAAAABQMwENAAAAAABAzQQ0AAAAAAAANRPQAAAAAAAA1Ky91QX0Vf++7vqcfd4FaTQ689oDDshhb3vLAvffeMut+eTJp2TkWmsmSfbefbe8913vTJI8PX16vvzVs3PfAw8kpeSk4z6eLTfbrO6XQM3+fe11Oesb53b1mQMPzLvf8fYF7r/x5lty/KdPmtdn9tgj7zv83XnwoYfy6c99fm67Rx97PEe+54i87c1vqrV+6nfNDTfmaxdcmM5GIwfvv18OO/TNC9x/02235VOf+2JGrjkiSbLXrrvmPe9429z7Ozs7855jP5aOYUNz5uc+W2vt1G/QVjtmg8OOSfr1y5N//2MeveSnC9zfsdsrs/bBXe87nc/OzL3/e1aeeejeJMnLjvxUBr98l8ye9lRu+dQRtddOa1w/9p5c8Ps/pbPRyAE7bpu37LPHYtuNe/jRfPQb38mJ73xT9thq88yaPTufOP97mT2nM52NRvbYcrMc9upX1Fw9rXDd7Xfm3J/+Mp2NKgfuuVvefuCrF9tu7H0P5MNfPD0nf/B92WuHbZMkv/rzZfnjFVellGSDddbOp957WFbq37/O8mmBa2+9Pef+6GddfWbvPfKO175mse3G3nt/PnTKl3LyMUdl7x23T5L8+k9/zR/+cUVSJQe+Ys+8ef9X1Vk6LXL9Xffk/N/9MY1Glf133i5v3XfPxbYb99Aj+cg5F+bEww7NnltvMXd9Z6ORo88+P8MGDsgX3veuusqmRT55yD7ZZaNRmTJjZo4472eLbXPMAXtk5w3Xz7Oz5+TU312Wex6fkCTZ8WXr5ej990hbv5I/3jQmP/3XTXWWTguttt4GGbH7q1P6lUwZc0sm3XT1AvevPnqjdOy4V5IqVaORJ//118x8/OEkSb+VVs5arzgoKw/tSKrk8csvycwnH23Bq6DPqqpWV0AvEND0gs7Ozpz5jW/m66d9JcM7huWIDx+TPXbdOaPXX3+BdttsuUW++qUvLLL92d88PzvvsH2+8tnPZPbs2Xn2uefqKp0W6ezszBlfOyff+OoZGd7RkcM/cFT22G3XbDBq1ALtttlqy5x16lcWWLf+euvlx9/9ztzHOehNb87ee+xeV+m0SGdnZ8785vk558tfzPBhQ/Pej3wse+y0U0avv94C7bbeYvMlhi+/vPj3GbXeupnxzDN1lEwrlX7Z4IiP5s6vfCKzJk3I1l/8VibfdFVmPvrg3CbPjn88t3/h2HTOmJ5BW++Ul73vuNx28geTJOOv+L88/pffZsMPntiqV0DNOhuNfPOiS/OVI9+VYQMH5Jivfzs7b75x1h8xfJF23/3jX7Pdxi+du65/e3tO/8C7s+rKK2dOZ2c+/s3/zQ6bvCybrr9u3S+DGnU2GjnnRz/PGccdm44hg3PU50/NrttslVFrr7VIuwt/dVF22GLeyUcTnpqS3/7t7/n+l07OyiutlFPO+3Yuv/aG7L/7LnW/DGrU2WjknB/8JGee8ImuPnPyF7Lbdttk1NojF2n3rV/8OjtsNe8g+30PP5I//OOKXPC5k9Le3p5Pnn52dtlmq6zTPCmFvqmz0ci5v70kpx51eNdn09kXZJfNN8n6ay762fSdP/wl2238skUe46Ir/p31hnfkGd+xVwh/umVsLrru9pz4+lcu9v6dNlw/6wwZlHd8/cfZbJ0R+diBe+VD3/l1+pWSj7xmrxz3o4szYdr0XPD+Q3PVuPvz4ISnan4F1K6UrLnnAXno9z/J7OnTMvrN783T99+dWU9NnNtkxiP3Z/r9dydJVh46PGu/+g2576cXJElG7PHqzHjo3jz6598k/fqlX7uTTYAXZoqzXjBm3LisM3Jk1h65Vvr3759X7b13rrjq393adsaMGbn59tvz2gP2T5L0798/a6y+em+Wy4vAmLvGZp21R2btkSO7+sw+++SKf13V48e5/qabss7IkVlrzTV7oUpeTMbcfXfWGblW1l5rzfTv3z+v3GvPXHnNNd3efvyEibn6uutz8Kv368UqebFY42Wb5tknH81z4x9P1TknE/59eYZst2CQ+/Q9d6ZzxvSu2/+5MysN6Zh737Sxt2XO9KdrrZnWGvfQoxk5bEjWGjok/dvbs/c2W+Tfd45bpN3FV12b3bfcLINWW23uulJKVl155STJnM7OdDY6U0qprXZaY+x9D2Tk8I6MHN6R/u3t2WfH7XPVzbcu0u6iv/09e2z/8gwasMYC6zs7G3lu1ux0dnbmuVmzMnTQwLpKp0XG3ntf1h4xfF6f2XnHXHXjzYu0++1fLsueO2y3QJ956LHHs9lLX5pVVl457W1t2WaTjXPlDc5u7+vGPfRIRg4bOvezaa+Xb5mr77hrkXYXX3lN9thq8wxaY8Hv0ROmTM11d92d/Xfevq6SabHbHnwsT898don377bx6Pz51rFJkjGPPJnVV1k5Q1Z/STZZe0QenTw1jz81LXM6G7n8jnuy28Yb1FU2LbTq8JGZNXVyZk+bkjQamXbPnVlj9EYLtKlmz557u197/6Q5oKFf/5XykpHrZcpdt3StaDTSmCUMBl6YgKYXTJg4KcOHzzuwNbxjWCZMmrhIu9vH3JV3HnlUPvo/n+6azizJo48/kcEDB+YLZ3w1h33gQ/nSV8/OzKXsUNA3jJ84MSOGzzvza3hHRyZMXEyfuXNM3vGe9+ajx38q991//yL3//Wyy7Pfvvv2aq28OEyYOCkjOua9z3QMG5YJkyYt0u6Ou8bmsA8dnY9/5rO578F5oyW+9q0L8+H3vif9+jlouiJYafCwzJo0fu7yrMkTsvKQYUtsP2LvAzPl1mvrKI0XqUnTpqVj0IC5y8MGDsjEqdMWaDNx6rRcfcfYHLjLoge6OhuNfPCs8/OWz52Rl2/40myy3jq9XjOtNfGpKRk+ZPDc5Y4hgzPxqSkLtJnw1JRcedOtee0rFpySqGPwoBy6/yvzluM+nTd+9ISstuqqC4ywoW+a8NSUdAwZMne5Y8jgTFi4z0x+Kv+64aa8dt+9F1g/ep21c9u4uzP16el59rnncs2tt2X8pMk1VE0rTZw6LR3zhbcdgwZm0tQFTyCZOGVarrr9rhy46w6LbH/+7y7N+w7aL/2cNEBTx4DVM2Ha9LnLE6ZNT8eA1dMxYLVMmPb0QutXW9xD0Me0r75G5kyft887e/rTaV9tjUXarTF642zw9qOy7kFvzeOXX5Ik6T9wcDpnzsha+xyc0Ye+L2u94sAUI2iAbnjBgKaU8svmv7eXUm5b6OfWUsrfSymH9H6py49qsfMBLrgTuMmGL8vvfvqj/PjCC3Lo6w7JJz/7uSRd0xaNu+c/ecPBB+WH3zovq66ySn7481/UUDUttZg+UxbqMxtvtGEu/sXP85P//W7e/MbX5/hPf2aB+2fPnp0rr746++y9V6+WyovXIn3mpS/Lb3/wv/nheefmTQcflBM+/8UkyVXXXpfBgwZlkw0XnfaBPmoxByKWNHXtwM1enhF7H5gHfvatXi6KF7PF9Y+FR8Fc8Ps/5b2veWXa+i26O9nWr1/O//gH85OTPp5xDz+aB554srdK5UWiymL2ZRbqM9/86a/ygTe/bpE+8/SMGbn65lvzs9O/kF+ffWqefW5W/nq1kLjPW+z+74LO/fHPcuRb37RIn1l/7ZF520EH5LhTv5pPnn52Xrreumlra+vFYnlRWOxn04LL51/cFcIs3GeuuXNcBq2+ejZad+1eLJC+YPHHc1z2YcXRvQD36fvH5b6fXpCHL/1VOnbau2vL0i+rdKyVp+68Mff/8jtpzJ6dYdvu2ou1An1Fd65B85Hmvwct4f5hSX6S5OL5V5ZSjkxyZJKc9ZUv5fCFLnjelw3vGJbx4yfMXR4/YWI6hg5doM1q800FsutOO+b0r5+bKVOnZnjHsHR0dGSLTTdJkuyz5+754c9+WU/htMzwjo48OX7e2e3jJ0zIsGEL9pnV5+szu+28c844+2uZMmVqBjXPIrv62muz8YYbZeh8ZyLSd3UMG5onJ8x7n5kwcWKGDV3wd7/aai+Ze3vXHXfImd88P1OmTs1tY8bkX9dcm39ff0NmzZ6VGc/MzCmnn5lTPnlcbfVTr1mTJ2SlofNG6a00pGOBeZSf95J1N8hL3398xpz2yQXOHGPFM2zggEyYMq8PTJw6LUMXmpLq7ocfy1d+8uskydQZz+S6sfekrV+/7LrFpnPbrL7qqtl6g1G5fux/Msq1Ifq0jsGDM37yvLn5J0x+apFpysY98GA+f/53kyRTp8/Itbfdkba2fpnT2Zk1O4bNncJqj+22yR3/uS+v2nWn+l4AtesYMjgTJs8b9TJh8lMZNnjQAm3G3f9gPn9u1wkDU5+enmtvvT1t/fplj+23zYF775ED994jSfLtX/wmHfON4KJvGjZoQCZMmTp3ecKUqRmyyGfTo/nyj7q+P0+d8Uyuu+vutPXrl7EPPpJr7hyb6++6O7PmzMkzzz6XU3/8q5zwzjfX+hp4cXl+xMzzOgasnolPz0h7W1s65utbz6+n75szfVraV583irz/6mtkzowlT/U88/GH0n/g4LStsmpmz5iW2dOn5dknH0uSTLv3LgEN0C0vGNBUVfV4898Hl9DkwVLKOxaz3YVJLkySpx5+YIU612DTjTfOw48+mscefyIdw4bmr//4Rz5/4gkLtJk0eXKGDB6cUkruHDs2VaORgQMGpJSSER3D8uDDD2f9ddfN9TfdsshFv+l7Nt1kkzz8yKN57PHH0zFsWP56+eX5wmdOWqDNpEmTM2RIs8/cdVcajSoDB87bcfjLZZdnv333qbt0WmTTjTbKI489lseeeCIdQ4fmb/+8Iqd86vgF2kya/FSGDB6UUkrGjBuXqqoycMCAfPCIw/PBIw5Pktx022356W8uEs70cU/fOzarrrlOVu5YM7MmT0zHLvtk3LlfWKDNSkOHZ5OPfSH3nPelPPvEIy2qlBeLjdcdmUcnTsoTk5/K0AFr5B+33JET3v7GBdr88MSPzr195s8vyk6bbZRdt9g0U6bPSHtbv6y+6qp5bvbs3PSf+3Lo3rvV/Aqo2yaj18+j48fn8QkTM2zwoFx+3Q056QPvWaDNz8744tzbp37nB9ll6y2z+7bbZMy992fMvffn2edmZeWV+uemMWOz8ej1634J1GzjDUbnkSeezOPjJ2TYkMG5/JrrctKHjlygzc/PPm3u7a9867vZ5eVbZ4/tt02SPDV1WgYPHJAnJ07KFTfclPNOObHW+qnfxuuunUcnTMrjk57KsIFr5J83354T3rVgwPKjkz4x9/YZP/ttdtpso+y25WbZbcvN8t6Duq69eOt/7s+v//Ev4Qy5etz9ef2OW+XyO+7JZuuMyIznZmXy9Gcy9ZmZWWfowKw5aI1MfHpG9tliw3zxN39pdbnUYOb4x7LSwCHpv8agzJ4xLQM23DyP/vWiBdr0Hzg4s6d2nZSyyrA1U/r1S+ezM5N0BTwrDRqSWVMmZ7V1Rue5xZwUB7Cw7oygSZKUUt6Q5LQkw9M15q8kqaqqGlBV1Y29VN9yqb2tLccd8+F85IQT02g0ctD++2WDUaPy20v+kCR5w8EH5fIrrsxvL/lD2trasvJKK+cLJ/3P3GkgPnH0h/PZr5yW2bPnZO211sxJx39iaU9HH9De3pbjPnpsjj3uk2k0Gjn4NQdkg9Gj89uLf58kecMhr83l//xnfnPxxV19ZuWV88XPfmZun3n22Wdz3Q035n8+8fFWvgxq1N7Wlo9/8Kh87KST09nZyEH7vSobrL9+LvrjpUmS1x/4mvz9X//KRX/8v7S19cvKK62cz5/wSRfqXlE1OnPf97+WzU84M+nXL+P/cWlmPvpA1tz3tUmSJy77fdZ7JZ6hjwAANylJREFUw7vTf42B2eCIj83d5taTPpAk2ejokzNw023SvsbAbP+NX+Wh33wv4/9xaateDTVoa2vLh1/3mpz47R+l0aiy344vz6g1h+cP/74+SXLQLovO7f+8ydOezpm/+F0ajUYaVZU9t948O2+2cV2l0yJtbW059h1vzSe/+o00Go0csMeuGb32yPz+71ckySLXnZnfZi8dnb22f3mOPOXLaWvrlw3XWzcH7bV7XaXTIu1tbfnIu9+R408/u6vP7LV7Rq+zdi6+7B9JkkMWuu7Mwk4+57xMmz497e1t+ei735E1VnN9iL6ura0tR7/hoJx44Q/SaDTy6h23zag1R+QPV1+XJDlo1x1bXCEvNp95437ZZtTaGfiSVfKrjx+e7/392rS3dU1/9/sb7sw19zyYnTZcPz859l15bvacnHbxZUmSzkaVcy69Ime865D0KyX/d/OYPDDBda5WCFWVJ678U9Z97dtSSr9MueuWzJo8MYM27zo5YMqdN2XABptk4CZbpWp0pjFnTh79y7wA54kr/5yRr3pdSr+2zJ42JY81r08DsDRlSfNrLtKwlP8kObiqqrt6+iQr2gga/v+U/iu1ugSWM53PGG5Oz4w96X2tLoHlzNpvParVJbCcWWmYKd3oGfvA9MSs8Y+1ugSWM+++fvwLN4L5nN8xpdUlsBza9MMnOSu0F4379hmOsfeijd9/fEv6b7dH0CR58r8JZwAAAAAAgP9e1ZDP9EU9CWhuKKX8Isnvkjz3/Mqqqn67rIsCAAAAAADoy3oS0AxI8kyS/eZbVyUR0AAAAAAAAPRAtwOaqqqO6M1CAAAAAAAAVhT9utuwlLJOKeWiUsr4UsqTpZTflFLW6c3iAAAAAAAA+qJuBzRJvpfk90lGJlk7ySXNdQAAAAAAAPRATwKajqqqvldV1Zzmz/eTdPRSXQAAAAAAAH1WTwKaiaWUd5ZS2po/70wyqbcKAwAAAAAA6Kt6EtC8J8mhSZ5I8niSNyU5ojeKAgAAAAAA6Mvae9D2C0neXVXVU0lSShmS5Mx0BTcAAAAAAEBvqBqtroBe0JMRNFs9H84kSVVVk5O8fNmXBAAAAAAA0Lf1JKDpV0oZ/PxCcwRNT0bgAAAAAAAAkJ4FLF9NcnUp5ddJqnRdj+ZLvVIVAAAAAABAH9btgKaqqh+WUm5Isk+SkuQNVVWN6bXKAAAAAAAA+qgeTVHWDGSEMgAAAAAAAP8fenINGgAAAAAAAJYBAQ0AAAAAAEDNBDQAAAAAAAA169E1aAAAAAAAgHpVjc5Wl0AvMIIGAAAAAACgZgIaAAAAAACAmgloAAAAAAAAaiagAQAAAAAAqJmABgAAAAAAoGYCGgAAAAAAgJoJaAAAAAAAAGomoAEAAAAAAKhZe6sLAAAAAAAAlqKqWl0BvcAIGgAAAAAAgJoJaAAAAAAAAGomoAEAAAAAAKiZgAYAAAAAAKBmAhoAAAAAAICaCWgAAAAAAABqJqABAAAAAACoWXurCwAAAAAAAJasajRaXQK9wAgaAAAAAACAmgloAAAAAAAAaiagAQAAAAAAqJmABgAAAAAAoGYCGgAAAAAAgJoJaAAAAAAAAGomoAEAAAAAAKiZgAYAAAAAAKBm7a0uAAAAAAAAWIpGZ6sroBcYQQMAAAAAAFAzAQ0AAAAAAEDNBDQAAAAAAAA1E9AAAAAAAADUTEADAAAAAABQMwENAAAAAABAzQQ0AAAAAAAANRPQAAAAAAAA1Ky91QUAAAAAAABLVlVVq0ugFxhBAwAAAAAAUDMBDQAAAAAAQM0ENAAAAAAAADUT0AAAAAAAANRMQAMAAAAAAFAzAQ0AAAAAAEDNBDQAAAAAAAA1E9AAAAAAAADUrL3VBQAAAAAAAEvRqFpdAb3ACBoAAAAAAICaCWgAAAAAAABqVssUZ1c+Pq2OpwFWUCu1t7W6BJYzgwcObnUJLGcaO+zb6hJYzqw8Y3KrS2A50z5i7VaXwHLkJZtsnSlX/qnVZbAcOb9jSqtLYDnzwQmDWl0Cy6F/tLoAWA4ZQQMAAADLEeEMAEDfIKABAAAAAAComYAGAAAAAACgZgIaAAAAAACAmgloAAAAAAAAatbe6gIAAAAAAIClqBqtroBeYAQNAAAAAABAzQQ0AAAAAAAANRPQAAAAAAAA1ExAAwAAAAAAUDMBDQAAAAAAQM0ENAAAAAAAADUT0AAAAAAAANRMQAMAAAAAAFCz9lYXAAAAAAAALFnV6Gx1CfQCI2gAAAAAAABqJqABAAAAAAComYAGAAAAAACgZgIaAAAAAACAmgloAAAAAAAAaiagAQAAAAAAqJmABgAAAAAAoGYCGgAAAAAAgJq1t7oAAAAAAABgyaqqanUJ9AIjaAAAAAAAAGomoAEAAAAAAKiZgAYAAAAAAKBmAhoAAAAAAICaCWgAAAAAAABqJqABAAAAAAComYAGAAAAAACgZgIaAAAAAACAmrW3ugAAAAAAAGApGo1WV0AvMIIGAAAAAACgZgIaAAAAAACAmgloAAAAAAAAaiagAQAAAAAAqJmABgAAAAAAoGYCGgAAAAAAgJoJaAAAAAAAAGrW3uoCAAAAAACAJasajVaXQC8wggYAAAAAAKBmAhoAAAAAAICaCWgAAAAAAABqJqABAAAAAAComYAGAAAAAACgZgIaAAAAAACAmgloAAAAAAAAaiagAQAAAAAAqFl7qwsAAAAAAACWomq0ugJ6gRE0AAAAAAAANRPQAAAAAAAA1ExAAwAAAAAAUDMBDQAAAAAAQM0ENAAAAAAAADUT0AAAAAAAANRMQAMAAAAAAFAzAQ0AAAAAAEDN2ltdAAAAAAAAsBSNqtUV0AuMoAEAAAAAAKiZgAYAAAAAAKBmAhoAAAAAAICaCWgAAAAAAABqJqABAAAAAAComYAGAAAAAACgZgIaAAAAAACAmrW3uoC+auxtN+f3P/peGo1Gdtx73+xz8OsXuP8ff7w4N119ZZKk0dnI+MceySnnfTcvWX2NrnWNzpxz8gkZOHhI3vOJ/6m9fuqnz9BTd91yU377w/9No9HIzq94ZV51yBsWuP+yS36XG6+6IknS2dmZJx99NF+68HtZaaWV8/XPn5Q5s2en0dnI1jvtkte8+a2teAnUaOBmL8/6h74vpfTL+Kv+msf/8tsF7h+6w54ZuV9XH+p87tk88LML8syjD8xrUPpli/85M7OmTMrd532pxspplRuuvTYXnHtOGp2N7H/gQTn0He9cpM1tN9+cb5379czpnJMBAwfmjHPOnXtfZ2dnjv3A+zNs2LB87tTT6yydFrnmhpvytQu/nc5GIwfv96ocduibFrj/pttuz6e+8OWMHDEiSbLXrjvnPW+f9/nT2dmZ93z0E+kYOjRnnvKZWmunNf599dX56plnptFo5JDXvS7vPvzwRdrceMMNOeusszJnzpwMGjQo37rwwm5vS99z/V135/yLLk2jamT/nbbLW1+512LbjXvokXzka9/KiYe9JXtus8Xc9Z2NRo4+6/wMGzggX3j/u+oqmxZabb0NMmL3V6f0K5ky5pZMuunqBe5fffRG6dhxryRVqkYjT/7rr5n5+MNJkn4rrZy1XnFQVh7akVTJ45dfkplPPtqCV0FdPnnIPtllo1GZMmNmjjjvZ4ttc8wBe2TnDdfPs7Pn5NTfXZZ7Hp+QJNnxZevl6P33SFu/kj/eNCY//ddNdZYOLMcENL2g0ejMRT/4bo781GcycMiQfP3k/8nm226fEWuvO7fN3gcekr0PPCRJMuamG3LFn/4w90B7klz550szfOTaeW7mzNrrp376DD3VaHTmV9/7dj504mczaOjQfPXTn8yW2+2QNdeZ12f2Pfh12ffg1yVJ7rjx+vzj0kuy2uprpKqqHH3S57LyKqumc86cnHPKp7PZNi/PqA03btGrodeVfhn11g9k7Nc/m1lPTcrmJ5yRKbddl5lPPDK3yXOTnsyYsz+dzmdmZODm22b0Oz6UO0//5Nz719znoMx84pG0rbJqK14BNevs7Mw3zzkrXz7z7Azr6MhHjnp/dtptt6w/avTcNtOffjrnfu2r+eLpX83wESMy5amnFniMi3/zq6y3/vp5ZsaMusunBTo7O3Pm+d/KOV/8XIYPG5r3fuy47LHzjhm93noLtNt6882WGL788vd/yKh1182MZ56po2RarLOzM6efdlrO/eY3M3zEiLz7sMOyx557ZoMNNpjb5umnn87pp52Wc77xjay55pqZPHlyt7el7+lsNHLuby7JqUcdkWGDBuSYsy/ILltsmvXXHL5Iu+9c8udst8mGizzGRVf8O+uN6Mgzzz5XV9m0UilZc88D8tDvf5LZ06dl9Jvfm6fvvzuznpo4t8mMR+7P9PvvTpKsPHR41n71G3LfTy9IkozY49WZ8dC9efTPv0n69Uu/9v4teRnU50+3jM1F192eE1//ysXev9OG62edIYPyjq//OJutMyIfO3CvfOg7v06/UvKR1+yV4350cSZMm54L3n9orhp3fx6c8NRiHwf+W1XVaHUJ9AJTnPWCh+79T4aNWDNDh49Ie3v/bLPzbrnzxhuW2P7ma/6Vl++y+9zlKZMnZewtN2Wnvfato1xeBPQZeurB//wnHWuulWEj1kx7e/9su8vuuf2G65bY/sar/5Vtd90jSVJKycrNg+ydnZ3p7JyTlFJL3bTG6qM2zLMTHs9zE59M1Tknk2/4VwZvvdMCbabfNy6dz3QdSJ9+/7isNHjo3PtWGjQ0g7bYPhOu+mutddM6d4+9KyPXXjtrjRyZ/v37Z6999s01V/1rgTb/uOxv2W2PvTK8ORpi0ODBc++bMH58rrvm33n1gQfVWjetM+bue7LOyDWz9lprpn///nnlnnvkymuW/Lm0sPETJ+bq62/Iwa9+VS9WyYvJnXfemXXWXTdrr7NO+vfvn/322y9X/POfC7T585/+lL1f8YqsueaaSZIhQ4Z0e1v6nnEPPZKRw4ZmrWFD0r+9PXu9fMtcfcddi7S7+MprssfWm2fQ6qstsH7ClKm5bsy47L/zdnWVTIutOnxkZk2dnNnTpiSNRqbdc2fWGL3RAm2q2bPn3u7X3j+pmrf7r5SXjFwvU+66pWtFo5HGLMFeX3fbg4/l6ZnPLvH+3TYenT/fOjZJMuaRJ7P6KitnyOovySZrj8ijk6fm8aemZU5nI5ffcU9229hJA0D3vGBAU0rZp/nvGxbz8/pSyl6llLbeL3X5Me2pyRk0ZN6BrYFDhmTqU5MW23bWc89l3G23ZMsd5h0o+/2Pv5cD3/rOlH7ysxWFPkNPTX1qUgYNnddnBg0dmqlPTV5s21nPPZext96crXfaee66RqMzp5/w8Xz6A0dk4y23zqiXbbTYbekbVho0ZIEzBWc9NSn9Bw1ZYvuOXV+ZKXfOG5K//pvfm4cu+kGqRtWrdfLiMXHChHR0zDsjeVhHRyZNmLhAm0cefjjTpz+dT37kmBxz5Hvztz//ae593zr363nvBz6UfsXn0opiwqRJGTFs2NzljmFDM2HSovsyd4wdl8OO/kg+fvLnct+DD81d/7ULv5MPH/Hu9HPCwApjwvjxGdEMeJNk+PDhmTB+/AJtHnrooTz99NM56sgjc9g735k//uEP3d6WvmfilGnpGDRw7nLHwAGZNHXaIm2uun1MDtx1x0W2P/+iS/O+g1/tfWYF0r76GpkzfV4fmT396bSvtsYi7dYYvXE2ePtRWfegt+bxyy9JkvQfODidM2dkrX0OzuhD35e1XnFgihE0K7yOAatnwrTpc5cnTJuejgGrp2PAapkw7emF1q+2uIcAWER3vjU/P6nrwYv5eW2STyT508IblVKOLKXcUEq54c8X/XoZlbt8qBZz/KosYSdwzM03ZNSGm8ydqmrMzTdm9QEDs87ol/ZmibzI6DP01OL6zJLccdP1Gb3xJlltvinx+vVryydPPSuf++a38+C9/8ljDz/YC1XyorG495Ml9KEBG22R4bu+Mg9f9MMkyaAtts/sp6fmmYfu7cUCWS4s1I0anZ25Z9y4fP7U0/PF07+an/3wB3nk4Ydy7dVXZdDgwdlwY9MmrlAWty+zUKfZ+GUvzW+/9+388Nxz8qaDD8wJX/xykuSq667P4IGDssmGL6ujUl4kFvsxtNDnVeecORl71105+5xz8vVzz83/fve7efDBB7u1LSuGhd9nzv/dH/O+g16dtoVOXLvmzrEZtMZq2Wjdtessj5br3vvC0/ePy30/vSAPX/qrdOy0d9eWpV9W6VgrT915Y+7/5XfSmD07w7bdtRdrZXlVLeHLeU++swMrthe8Bk1VVZ9t/nvEktqUUr67mO0uTHJhkvz+uttWqLelgUOGZMrkeWcMTp08OQOWcKbyLddclZfvstvc5QfuHpsxN92QsbfenNmzZ+W5mTPz0/O/nrd/8Nher5vW0WfoqUFDhmbKfGcmT5k0KQMHL77P3HT1v7Ltrrsv9r6XrLZaXrbp5hl7680Zue76vVIrrTfrqUlZafC8M9tXGjw0s6cuOuJq1bXXz+h3Hp1x534+c2Z0nQG2xks3yeCtdsigLbZLae+ftlVfkpce/tHc+/2v1VU+LTCsoyMTJsw7G33ihAkZOt/oiOfbDBg4MKusumpWWXXVbLH11rn/3nvzn7vH5Zqrrsr111yT2bNm5ZlnZuT0L34+nzzp5LpfBjXqGDY0T06cN8pqwsRJGTZ0wc+l1V7ykrm3d91h+5x53rcyZeq03Dbmrvzr2uvy7xtuzKxZszJj5jM55YyzcsrxH6+tfuo3fPjwPPnkk3OXx48fn46OjgXbjBiRgYMGZdVVV82qq66abV7+8txzzz3d2pa+Z9igAZkwZerc5QlTp2XIwAVHQ9z98KP58g9/kSSZOuOZXHfX3Wlr65exDz6Sa+4Ym+vH3J1Zc+bkmWefy6k//lVOeOeba30N1GvO9GlpX33A3OX+q68xdx93cWY+/lD6DxyctlVWzewZ0zJ7+rQ8++RjSZJp994loGHuiJnndQxYPROfnpH2trZ0DFhjkfUA3fGCAc3zSikrJ3ljklHzb1dV1eerqnrvsi9t+bXuBi/LxCcez+TxT2bAkCG55Zqr8vYPfWSRdjOfmZH7xo7J24+adyD9NW95R17zlnckSe69687889LfO9C+AtBn6Kn1XvqyTHji8Uwa/2QGDhmSm/79rxx29McWaTfzmRm5964xedeHPzp33fRpU9OvrT0vWW21zJr1XO6+47bs+9rX11g9dZv+4D1ZZfhaWXno8MyaMjlDtt899/7vWQu0WWnwsGx05Am59/tn59nxj81d//DFP87DF/84SbLGhltkrVcdIpxZAWy08SZ57JFH8sTjj2XosI788/LL8qmTPrtAm5133z3nnXN2OufMyew5czJuzJi8/k2HZo+9X5EjjjwqSXLbzTfnN7/4mXBmBbDpRhvmkUcfz2NPPJmOoUPytyuuzCnHf2KBNpMmP5UhgwellJIx4+5OVTUycMAa+eDhh+WDhx+WJLnpttvz09/+TjizAthss83y8MMP59FHH83w4cPzl7/8JV/44hcXaLPnXnvljNNPz5w5czJnzpzceccdefvb3571R416wW3pezZed+08OmFSHp80OcMGDsg/b759kYDlR585bu7tM376m+y02cbZbcvNstuWm+W9B+2XJLn1P/fl13+/SjizApg5/rGsNHBI+q8xKLNnTMuADTfPo3+9aIE2/QcOzuypXRdyX2XYmin9+qXz2ZlJugKelQYNyawpk7PaOqPz3FMTF3kOVixXj7s/r99xq1x+xz3ZbJ0RmfHcrEye/kymPjMz6wwdmDUHrZGJT8/IPltsmC/+5i+tLhdYTnQ7oElycZKpSW5M4spoS9HW1pbXHfbefPuML6XRaGTHPV+RNddZN/++rOvNeZd9u3YM77jhumy0xdZZaZVVWlkuLwL6DD3V1taWNx7+vpz/lc+n0Whk5733zVrrrpd//fXPSZLdX/XqJMlt11+bjbfaOivP12emPvVUfnL+N9JoNFJVjbx8592yxbbbt+R1UJNGIw/8/NvZ+JjPpvRry4Sr/5aZjz+c4Xt09ZPxV/45ax/4lrSvvkZGvbXrwHrV6Mydpx63tEelD2trb88HP/KxnHT8J9LZaGS/Aw7M+qNH548X/y5JcuAhr8t664/K9jvulA++9/D0K/3y6gMPyqgNXAx1RdXe1paPf/DIfOwzp6Sz0chBr9o3G6y/Xi669P+SJK9/zQH5+1VX56JL/y9tbW1ZeaWV8vlPHrfEKV3p+9rb23P88cfn2GOOSaOzMwe/9rV56Utfmt/8umt67De+6U0ZPXp0dtlll7zjbW9LKSWHvO51eenLuqbCW9y29G1tbW05+o0H5cRv/SCNRiOv3mm7jFprRP5w1XVJkoN2W/S6M6zgqipPXPmnrPvat6WUfply1y2ZNXliBm2+bZJkyp03ZcAGm2TgJlulanSmMWdOHv3LvADniSv/nJGvel1Kv7bMnjYljzWvT0Pf9Zk37pdtRq2dgS9ZJb/6+OH53t+vTXtb15SJv7/hzlxzz4PZacP185Nj35XnZs/JaRdfliTpbFQ559Ircsa7Dkm/UvJ/N4/JAxMWf41YgIWVJc2VuEjDUu6oqmqL/+ZJVrQpzoB6rdTe1uoSWM4M/vanW10Cy5mOky9sdQksZwbO8KWcnmkf4doYdN+UKxe5DCws1TP3j2t1CSxnPjhhUKtLYDn0j1OOdvZNL7r188c6xt6Ltj756y3pv/1euMlcV5dStuy1SgAAAAAAAFYQPZnibPckh5dS7k/XFGclSVVV1Va9UhkAAAAAAJCq0dnqEugFPQloDui1KgAAAAAAAFYg3Z7irKqqB5MMSnJw82dQcx0AAAAAAAA90O2AppTykSQ/STK8+fPjUsoxvVUYAAAAAABAX9XtgCbJe5PsVFXVyVVVnZxk5yTv752yAAAAAAAAXhxKKfuXUsaVUv5TSjlhMfcfUkq5rZRySynlhlLK7i/0mD25Bk1JMv+ViDqb6wAAAAAAAPqkUkpbkm8meVWSR5JcX0r5fVVVY+ZrdlmS31dVVZVStkryyySbLO1xexLQfC/JtaWUi5rLr0vy3R5sDwAAAAAAsLzZMcl/qqq6L0lKKT9PckiSuQFNVVXT52u/WpLqhR6021OcVVV1VpIjkkxO8lSSI6qq+lp3twcAAAAAAHixKaUc2ZyW7PmfIxdqsnaSh+dbfqS5buHHeX0pZWySPyZ5zws9b7dH0JRSdk5yZ1VVNzWX1yil7FRV1bXdfQwAAAAAAIAXk6qqLkxy4VKaLO5yL4uMkKmq6qIkF5VS9kzyhSSvXNrz9mSKs/OTbDvf8ozFrAMAAAAAAJal6gVny6J3PZJk3fmW10ny2JIaV1V1RSnlpaWUYVVVTVxSu25PcZakVNW8XlBVVSM9C3gAAAAAAACWN9cn2bCUMrqUslKStyb5/fwNSikvK6WU5u1tk6yUZNLSHrQnAct9pZRj0zVqJkk+lOS+HmwPAAAAAACwXKmqak4p5egkf07SluR/q6q6s5RyVPP+C5K8MclhpZTZSWYmecv8g14WpycBzVFJvp7kpHTNrXZZkoUvlAMAAAAAANCnVFV1aZJLF1p3wXy3T0tyWk8es9sBTVVV49M1bGexSin/U1XVV3ry5AAAAAAAACuinlyD5oW8eRk+FgAAAAAAQJ+1LAOasgwfCwAAAAAAoM9algHNUi92AwAAAAAAQBcjaAAAAAAAAGrWvgwf61fL8LEAAAAAAIAkaZjAqi/q9giaUsrppZQBpZT+pZTLSikTSynvfP7+qqq+3DslAgAAAAAA9C09meJsv6qqpiU5KMkjSTZKcnyvVAUAAAAAANCH9SSg6d/898AkP6uqanIv1AMAAAAAANDn9eQaNJeUUu5K8mySD5ZSOpq3AQAAAAAA6IGeBDSfSzIpyZ5Jfp7kliSvW/YlAQAAAAAA9G09meLsB0k2TnJWknOTrJvknN4oCgAAAAAAoC/ryQiajauq2nq+5b+XUm5d1gUBAAAAAAD0dT0JaG4upexcVdU1SVJK2SnJVb1TFgAAAAAAkCRVo7PVJdALehLQ7JTksFLKQ83l9ZLcVUq5PUlVVdVWy7w6AAAAAACAPqgnAc3+vVYFAAAAAADACqTbAU1VVQ/2ZiEAAAAAAAArin6tLgAAAAAAAGBFI6ABAAAAAAComYAGAAAAAACgZgIaAAAAAACAmgloAAAAAAAAatbe6gIAAAAAAIClqBqtroBeYAQNAAAAAABAzQQ0AAAAAAAANRPQAAAAAAAA1ExAAwAAAAAAUDMBDQAAAAAAQM0ENAAAAAAAADUT0AAAAAAAANRMQAMAAAAAAFCz9lYXAAAAAAAALFlVVa0ugV5gBA0AAAAAAEDNBDQAAAAAAAA1E9AAAAAAAADUTEADAAAAAABQMwENAAAAAABAzQQ0AAAAAAAANRPQAAAAAAAA1ExAAwAAAAAAULP2VhcAAAAAAAAsRaPR6groBUbQAAAAAAAA1ExAAwAAAAAAUDMBDQAAAAAAQM0ENAAAAAAAADUT0AAAAAAAANRMQAMAAAAAAFAzAQ0AAAAAAEDNBDQAAAAAAAA1a291AQAAAAAAwJJVjc5Wl0AvMIIGAAAAAACgZgIaAAAAAACAmpWqqlpdwwqtlHJkVVUXtroOlg/6Cz2lz9BT+gw9pc/QU/oMPaXP0BP6Cz2lz9BT+gytcuPxhzmQ34u2O+OHpRXPawRN6x3Z6gJYrugv9JQ+Q0/pM/SUPkNP6TP0lD5DT+gv9JQ+Q0/pM8AyI6ABAAAAAAComYAGAAAAAACgZgKa1jNnJT2hv9BT+gw9pc/QU/oMPaXP0FP6DD2hv9BT+gw9pc8Ay0ypKtcWAgAAAACAF6sbjz/MgfxetN0ZPyyteN72VjwpAAAAAADQTQZa9EmmOAMA4EWvlHJ4KWVkq+sAAACAZUVAAwDA8uDwJAIaAKA2pZSRpZRft7oOAPouAU03lFK+X0p5U6vr6Clnmi6fmr+3c1v4/NuUUl7TqufvS0op01tdQ6uUUvYupeza6jpWBPO/Z5RSTimlHNfqmpaFUsqoUsrbW13H8qj5f3dXKeXbpZQ7Syl/KaWs2nx/v6aUclsp5aJSyuBm+3+UUrZv3h5WSnmgefvwUspvSyl/KqXcU0o5/QWed/9Syk2llFtLKZc11w0ppfyu+ZzXlFK2aq5foK+WUu5o1r2k2t+UZPskPyml3FJKWbVX/vPotoXee44qpRzWwlp85ixnXkz7SPrPi0+rvw8tib6yYqqq6rGqqpa740G8uJVSPl9KeWWr6wBeHAQ0vax0adX/8+FxpumLXimlrdU1LGSbJAIa/n/tncQX2OVQKaV9acs1GpVEQPPf2zDJN6uq2jzJlCRvTPLDJJ+qqmqrJLcn+Ww3HmebJG9JsmWSt5RS1l1co1JKR5JvJ3ljVVVbJ3lz867PJbm5+ZwnNmvoce1VVf06yQ1J3lFV1TZVVc3sxuNQk6qqLqiqqju/296yd3zmLBda/N1oSfaO/kP37B19ZblTSjmseaLIraWUH5VS1i+lXNZcd1kpZb1mu++XUr5eSrm6lHLf8yfpNk8euaO1r4K+pqqqk6uq+lur6wBeHF5sO8cvCgt/gDdX77mYD+rVmx/oN5VSbi+lHNJc//zZn+cluSnJkg5mONN0OVdK+WQp5djm7bNLKZc3b+9bSvlxKeVtzb5xRynltPm2m948Y+LaJLuUUo4opdxdSvlnkt1e4DlHlK4zn29t/uzaXP/x5vPcUUr5aHPdAjuTpZTjSimnNG//o5RyWinluuZz71FKWSnJ59N1EO6WUspbluX/14qslHJ8KeX65t/255rrRpVSxpZSvtP8vf2klPLKUspVpets9R2b7U4ppfyg+ff9QCnlDaWU05t960+llP7Ndic3n+OOUsqFpZSylHpeVkr5W7MP3VRKeWnpckZz+9uf//2XrrMF/zDftueWUg5v3n6glPK5+d4HNymljEpyVJKPNfvRHr31/7q8K6WsVkr5Y/P3cEcp5S3N/9Pn/zavK6W8rNm2o5Tym+bv+PpSylLfK5bwfC9t9pkbSylXllI2aa7/finlrFLK35OctvDyEh5r9VLK95q/99tKKW9srl/i+958t99USvn+fM+9yJfhJKcm2aPZhz7W09dK7q+q6pbm7RuTvDTJoKqq/tlc94Mke3bjcS6rqmpqVVXPJhmTZP0ltNs5yRVVVd2fJFVVTW6u3z3Jj5rrLk8ytJQysIe1j+pGnSxjpWt/9MbStX95ZHPdEWUx+yvlBUbv+czpe5qfUx+ab/mUUsonypL3dxb5blRK+Wrzd3lZ6Qp5l/Rc+k8f0933l1LKwObvrV9z+SWllIdLc993MY+rr7CAUsrmST6dZJ/mCSQfSXJukh82Tx75SZKvz7fJWunadzkoXfui9DFl3nfwHzQ/q37dfG85tZQyprnuzKVs39PjMYscr2ve9/2yHM7UA/QOAc1ClvABniz+g/rZJK+vqmrbJK9I8tVS5h4Q3ThdH/ovr6rqwcU8jzNN+4Yrkjy/c759ktWbXxh2T3JPug5s7pOuM5B3KKW8rtl2tSR3VFW1U5J70/V73y3Jq5Js9gLP+fUk/2z2m22T3FlK2S7JEUl2StdBsveXUl7ejfrbq6raMclHk3y2qqpZSU5O8otmv/lFNx6DF1BK2S9df6c7pqsvbFdKef7A6MuSnJNkqySbpGvEwO5JjkvXe8DzXprkwCSHJPlxkr9XVbVlkpnN9UlyblVVO1RVtUWSVdP1frUkP0nX+8bW6ToT8PEkb2jWt3WSVyY5o5SyVjde4sTm++D5SY6rquqBJBckObvZj67sxmOsqPZP8lhVVVs3f29/aq6f1vzbPDfJ15rrzknX/+kO6RoN8Z3/4vkuTHJMVVXbpauPnTfffRsleWVVVZ9YwvLCPpNkalVVWzY/sy4vXdNqLul9b2kW9xl7QpIrm33o7O6+QOZ6br7bnUkGLaXtnMzbJ1zlBR5nSSOqSpJqCesXVi30nAs/b3efk971nuZ7xfZJji2lrJ2e7a/Mz2dO3/PzdI2ue96hSSZkyfs7C383Wi3JTc3f5T+z9BF9+k/f0633l6qqpia5Ncleze0OTvLnqqpmL+Fx9RUWtk+SX1dVNTGZewLJLkl+2rz/R+naB33e76qqalRVNSbJiForpU4bJ7mw+R1mWpKjk7w+yebNdV9cyrY9PR6zuFHtAAsQ0CxqcR/gyeI/qEuSL5dSbkvytyRrz3ffg1VVXbOU53Gmad9wY7q+fK6RrgNK/07XF4090vXh+4+qqiZUVTUnXV8Ynv+S2pnkN83bO83XblaSFwpF9knXF4VUVdXZ/OKye5KLqqqaUVXV9CS/zbzgaGl+O9/rGNWN9vx39mv+3JyuM0c3SdeOWtL193t7VVWNJHem62z1Kl3TD42a7zH+r/ll9PYkbZl3IH/+dq8opVxbSrk9Xf1k88UV0+yva1dVdVGSVFX1bFVVz6SrH/2s2a+eTNcBkx268fr0o//e7UleWbrORN6j+fecJD+b799dmrdfmeTcUsotSX6fZEDzd9ktpZTV03Ww4lfNx/hWuoKR5/2qqqrOpSwv7JVJvvn8QlVVT6WrvyzpfW9pfBnufVOTPDXfGb/vStffeJI8kGS75u3/9ky+fyfZq5QyOukaEdxcf0WSdzTX7Z2uA17Tms+5bXP9tklGd+M5nk7S7T7P/7djSym3JrkmXSMe3pWe7a8k8ZnTV1VVdXOS4aXr4tlbJ3kqXSebLGl/Z+HvRo3M60M/zoIHSOfSf/qsnry//CLzwsC3ZgnvPfoKS7CkE0jmN//9858kssTZCFjuPVxV1VXN2z9O1/eVZ5N8p5TyhiTPLGXbnh6PcbwOeEHOSFzUkj7AF/dB/Y4kHUm2q6pqdum6qO7zZ4DO+C+fZ1mcaWo6s5rM93s/IsnVSW5L12iqlyZ5KPMOeC3s2YUOfL7QTuMLWdLO49L6TTKv7zhDuXeVJF+pqupbC6zsmiph/r/fxnzLjSz4O3kuSaqqapRSZjdDnLntSimrpGs0xPZVVT1cuqayW/j3PX89PVmvH/WSqqrubp5x9ZokXyml/OX5u+Zv1vy3X5JdqoVGRJYlz2S3sH5JplRVtc0S7l/4c+u/+RxbWjHzt13aKA1fhnvPu5NcUEp5SZL70vXZlSRnJvllKeVdSS7/bx64qqoJpWuamt82p6IZn66zoE9J8r3mySzPNGtIuk5SOKwZFl6f5O5uPM33m/XPzGL+Flh2mmHaK9P1//xMKeUfScYm2fS/ebgerveZs/z4dbpC3TXTNaJmVJa8v/NCnylL2hfWf/qY/+L95ffp2kcakq7vVkv6nNJXWJzLklxUSjm7qqpJzX50dbrCvh+l65jOv1pZIC2x8GfO7HSN/tw3XX3j6HQFMd21tO8vjtcBL8gImkVdluTQUsrQZIEzQBdnYJLxzYP0r8iS52VfHGea9h1XpGuqoCuSXJmuuYlvSdcZYXuVUoaVUtqSvC3zzlae37VJ9i6lDG1Oj/bmxbSZ32VJPpgkpZS2UsqA5nO/rjl36mrpGp57ZZIn03V249BSyspZ+pRXz9Nvlr0/J3lPcwRDSilrl1KGL+PneP5L5cTm8yzxLPjme8ojz089VUpZuXnA9op0XX+orTkN455JrkvyYJLNmu0GpmvH9YXoR93QnBLsmaqqfpyug+TbNu96y3z//rt5+y/p+rLw/Lbb9OS5mr/3+0spb25uX5pnPf+3Fq5ncLrez5b0vvdkKWXT5sH713fj8fWh/1JVVQ9UXVPmPb98ZlVVp1RVdUtVVTtXVbVVVVWva456SlVVY5vrdq2q6qSqqkY113+/qqqj53ucg6qq+sdSnvf/qq7pi7auqupVzXWTq6o6pPn4O1dVdVtz/cyqqvaruqaJeX9VVZs2615s7c3bv6mqauPK1K11GJjkqebB003SNfJ71fRsfyWJz5w+7ufpOpD1pnSFNT3Z3+mXefsqb88SDpDqP31Sj95fmmejX5euqV7/sKTRvfoKi1NV1Z1JvpTkn81RW2clOTbJEc2TR96VedPaL/Wheq9KWmC9UsrzsxS8LV3HbwZWVXVpuqZ/32Yp2/bkeAwsc1Wj8tOLP63iTJCFVFV1Zynl+Q/wznQN0V+SnyS5pJRyQ7re0Mf24Hmcadp3XJmu6xb9u6qqGaWUZ9N13YTHSyn/k+Tv6Tqj4tKqqi5eeONmu1PSdRD28XRNCdG2lOf7SJILSynvTdcZGB+squrfpeuC29c123ynOfVESimfT9dB0/vTvT769yQnNPvaVyrXofn/VlXVX0opmyb5d3O0w/Qk70zX729ZPceUUsq30zVl1gPpep9Ymncl+Vazf8xO1xfhi9I1ndat6foS8smqqp5IklLKL9M1QuyeLP198XmXJPl1KeWQdF3zxA7q4m2ZrrnQG+n6PXwwXQe5Vi6lXJuuA1hva7Y9Nsk3m58P7en6InBUD5/vHUnOL6WclKR/ug6u3fpf1v7FZj13pKsvf66qqt8u5X3vhCR/SPJwkjuSrP4Cj39bkjnNL9Pfr1yHBur0pyRHNd9vxqXrpJPH07WfuqT9laV9o/GZ0wc1vzetkeTRqqoeT/J4D/Z3ZiTZvJRyY7qmYHzLYto8T//pW/6b95dfJPlVkr1f4LH1FRZRVdUPkvxgodWLjI6oqurwhZaf31cdmmTywu1Zrt2V5N2llG+l6+//lCR/KF2zUpQkH1vKtt0+HlO6RpAujeAPSJKUebPkAACtVrqmTdy+al4LDV5smuHhygutfldVVbe3oh5ar5TyjXRd8P17ra4FAJaVUsr2SX6a5ISqqn77Qu158WuGJn+Yf8R2i+q4JMlZVVX9vZV1sPy54ePvdCC/F21/1o9bMuW6ETQAAHRbVVU7tboGXjxKKV9IslO6zj4FgD6jqqobkmzU6jroW0op/5vkJXH9I6BJQFMDZ5ry3yilfDqLzu/+q6qqvtSKelg+lVK+mWS3hVaf4yznF6/nr//x/2NZ/t5LKUdk0bm5r6qq6sP/bX1A31FV1WeSfCbxmcP/H/2H7tJXgP9WVVUPJHnB0TO9eTymqqr3/P8+BtC3mOIMAAAAAABexExx1rtaNcVZv1Y8KQAAAAAAwIpMQAMAAAAAAFAzAQ0AAAAAAEDN2ltdAAAAAAAAsBSNzlZXQC8wggYAAAAAAKBmAhoAAAAAAICaCWgAAAAAAABqJqABAAAAAAComYAGAAAAAACgZgIaAAAAAACAmgloAAAAAAAAatbe6gIAAAAAAIAlq6pGq0ugFxhBAwAAAAAAUDMBDQAAAAAAQM0ENAAAAAAAADUT0AAAAAAAANRMQAMAAAAAAFAzAQ0AAAAAAEDNBDQAAAAAAAA1E9AAAAAAAADUrL3VBQAAAAAAAEtRVa2ugF5gBA0AAAAAAEDNBDQAAAAAAAA1E9AAAAAAAADUTEADAAAAAABQMwENAAAAAABAzQQ0AAAAAAAANRPQAAAAAAAA1ExAAwAAAAAAULP2VhcAAAAAAAAsWdVotLoEeoERNAAAAAAAADUT0AAAAAAAANRMQAMAAAAAAFAzAQ0AAAAAAEDNBDQAAAAAAAA1E9AAAAAAAADUTEADAAAAAABQMwENAAAAAABAzdpbXQAAAAAAALAUjUarK6AXGEEDAAAAAABQMwENAAAAAABAzQQ0AAAAAAAANRPQAAAAAAAA1ExAAwAAAAAAUDMBDQAAAAAAQM0ENAAAAAAAADUT0AAAAAAAANSsvdUFAAAAAAAAS1ZVjVaXQC8wggYAAAAAAKBmAhoAAAAAAICaCWgAAAAAAABqJqABAAAAAAComYAGAAAAAACgZgIaAAAAAACAmgloAAAAAAAAaiagAQAAAAAAqFl7qwsAAAAAAACWolG1ugJ6gRE0AAAAAAAANRPQAAAAAAAA1ExAAwAAAAAAUDMBDQAAAAAAQM0ENAAAAAAAADUT0AAA8P/au2NWOeoojMPvIYtfwNIoWNikiI1YXRA7U9lGxEoIFn6AVDZ+BkWCWKeysBH7EAQ7wUIJWhjsxF5y91i4xRLu7AoyZ5Q8D9xiduf+99T748wCAAAAwwQaAAAAAACAYQINAAAAAADAsN3WAwAAAAAAAMt6f7n1CKzABg0AAAAAAMAwgQYAAAAAAGCYQAMAAAAAADBMoAEAAAAAABgm0AAAAAAAAAwTaAAAAAAAAIYJNAAAAAAAAMMEGgAAAAAAgGG7rQcAAAAAAABO6P3WE7ACGzQAAAAAAADDBBoAAAAAAIBhAg0AAAAAAMAwgQYAAAAAAGCYQAMAAAAAADBMoAEAAAAAABgm0AAAAAAAAAzbbT0AAAAAAACwrLu3HoEV2KABAAAAAAAYJtAAAAAAAAAME2gAAAAAAACGCTQAAAAAAADDBBoAAAAAAIBhAg0AAAAAAMAwgQYAAAAAAGCYQAMAAAAAADBst/UAAAAAAADACfveegJWYIMGAAAAAABgmEADAAAAAAAwTKABAAAAAAAYJtAAAAAAAAAME2gAAAAAAACGCTQAAAAAAADDBBoAAAAAAIBhAg0AAAAAAMCw3dYDAAAAAAAAy3p/ufUIrMAGDQAAAAAAwDCBBgAAAAAAYJhAAwAAAAAAMEygAQAAAAAAGCbQAAAAAAAADBNoAAAAAAAAhgk0AAAAAAAAwwQaAAAAAACAYbutBwAAAAAAAE7o/dYTsAIbNAAAAAAAAMMEGgAAAAAAgGECDQAAAAAAwDCBBgAAAAAAYJhAAwAAAAAAMEygAQAAAAAAGCbQAAAAAAAADBNoAAAAAAAAhu22HgAAAAAAADhh31tPwAps0AAAAAAAAAwTaAAAAAAAAIYJNAAAAAAAAMMEGgAAAAAAgGECDQAAAAAAwDCBBgAAAAAAYJhAAwAAAAAAMEygAQAAAAAAGLbbegAAAAAAAGBZ7y+3HoEV2KABAAAAAAAYJtAAAAAAAAAME2gAAAAAAACGCTQAAAAAAADDBBoAAAAAAIBhAg0AAAAAAMAwgQYAAAAAAGCYQAMAAAAAADBst/UAAAAAAADAsu791iOwAhs0AAAAAAAAJ1TVW1X1Y1U9qqq7V7z/blV9f/h7WFWvnjtToAEAAAAAAFhQVdeSfJLkVpIbSd6pqhtP3fZLkje6+2aSj5PcO3euQAMAAAAAALDs9SSPuvvn7v4zyf0kbx/f0N0Pu/uPw+W3Sa6fO1SgAQAAAAAAWPZCkl+Prh8fXlvyfpKvzx26+5dDAQAAAAAA/G9V1Z0kd45eutfdx48oqyv+rRfOejN/B5qLc58r0AAAAAAAAM+sQ4w59Zsxj5O8eHR9PclvT99UVTeTfJ7kVnf/fu5zPeIMAAAAAABg2XdJXqmql6vquSS3k3x1fENVvZTkyyTvdfdP/+RQGzQAAAAAAAALuvtJVX2Y5Jsk15J80d0/VNUHh/c/S/JRkueTfFpVSfKku187dW51X/mYNAAAAAAA4D/gwe0LX+Sv6OL+g6t+Y2Z1HnEGAAAAAAAwTKABAAAAAAAYJtAAAAAAAAAME2gAAAAAAACGCTQAAAAAAADDBBoAAAAAAIBhAg0AAAAAAMCw3dYDAAAAAAAAJ+x76wlYgQ0aAAAAAACAYQINAAAAAADAMIEGAAAAAABgmEADAAAAAAAwTKABAAAAAAAYJtAAAAAAAAAME2gAAAAAAACGCTQAAAAAAADDqru3ngEAAAAAAOCZYoMGAAAAAABgmEADAAAAAAAwTKABAAAAAAAYJtAAAAAAAAAME2gAAAAAAACGCTQAAAAAAADD/gIB+8jTUfIjWwAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 1800x1800 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 计算特征与特征之间的皮尔森系数，画热力图\n",
    "import seaborn as sns\n",
    "plt.figure(figsize = (25,25))\n",
    "corr_values = processed_features.iloc[:,1:].corr() # pandas直接调用corr就能计算特征之间的相关系数\n",
    "#遮住上半部分\n",
    "mask = np.zeros_like(corr_values, dtype=np.bool)\n",
    "mask[np.triu_indices_from(mask)] = True\n",
    "# 绘制热力图\n",
    "sns.heatmap(corr_values, annot=True,vmax=1, square=True, cmap=sns.diverging_palette(20, 220, n=200),fmt='.2f',xticklabels=True, yticklabels=True)\n",
    "plt.tight_layout()\n",
    "# plt.savefig('prepare_data/columns37.png',dpi=600)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  数据标准化-使用standardscaler"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2.71804079e+04, 1.49315496e+03, 4.62845151e+02, 1.67870870e+01,\n",
       "       6.35621402e+01, 1.96189525e+01, 7.47426380e+01, 1.29950948e+01,\n",
       "       4.89634042e+00, 1.78926628e+01])"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.preprocessing import StandardScaler\n",
    "X = processed_features.iloc[:,1:].values\n",
    "y = processed_features[\"score\"].values\n",
    "scaler = StandardScaler() #实例化\n",
    "scaler.fit(X) #fit，本质是生成均值和方差\n",
    "scaler.mean_ #查看均值的属性mean_\n",
    "scaler.var_ #查看方差的属性var_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_new = scaler.fit_transform(X) #使用fit_transform(data)一步达成结果\n",
    "#scaler.inverse_transform(x_std) #使用inverse_transform逆转标准化"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.08215492, -0.10734228,  0.54338564, ...,  0.52210409,\n",
       "        -0.54311994, -0.15752673],\n",
       "       [ 0.54259936,  0.35847979,  0.54338564, ...,  0.52210409,\n",
       "         0.36072555,  1.26092239],\n",
       "       [ 0.90653389,  1.0572129 ,  0.77579421, ...,  1.07690897,\n",
       "         1.71649377,  1.49733057],\n",
       "       ...,\n",
       "       [-3.06641808, -3.05754875, -3.31459668, ..., -1.97451785,\n",
       "        -1.44696543, -2.04879223],\n",
       "       [-3.06641808, -3.05754875, -3.31459668, ..., -1.97451785,\n",
       "        -1.44696543, -2.04879223],\n",
       "       [-3.06641808, -3.05754875, -3.31459668, ..., -1.97451785,\n",
       "        -1.44696543, -2.04879223]])"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_new"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 构建新的特征矩阵（把原来的向量和他连在一起）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = np.concatenate((X_new, X_cv), axis = 1)\n",
    "y = y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 划分训练集与测试集"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 线性回归"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "测试集得分：\n",
      " 0.5826263252250543\n",
      "LinearRegression Coefficients: \n",
      " [ 4.36545172e-02  2.44804532e+00  2.09207248e+00 ... -9.48924327e-04\n",
      "  2.58614290e-02  8.11534189e-02]\n",
      "LinearRegression Mean squared error: 10.32\n",
      "R2:0.582626\n",
      "--------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "linear_regressor = LinearRegression()\n",
    "linear_regressor.fit(X_train, y_train)\n",
    "y_pred = linear_regressor.predict(X_test)\n",
    "\n",
    "# The coefficients 表示每一个特征所占的权重\n",
    "print(\"测试集得分：\\n\",linear_regressor.score(X_test,y_test))\n",
    "print('LinearRegression Coefficients: \\n', linear_regressor.coef_)\n",
    "# The mean squared error\n",
    "print(\"LinearRegression Mean squared error: %.2f\" % mean_squared_error(y_test, y_pred))\n",
    "# 平均绝对百分比误差（Mean Absolute Percentage Error）\n",
    "#print('LinearRegression MAPE:%.2f' % np.average(np.abs((y_test-y_pred)/y_test)))\n",
    "print(\"R2:%f\"% r2_score(y_test, y_pred))\n",
    "print('-' * 50)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 岭回归"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "测试集得分：\n",
      " 0.6296487860040489\n",
      "Ridge Coefficients: \n",
      " [ 0.59313596  0.48631253  1.11376315 ... -0.00515962  0.00607232\n",
      "  0.00862623]\n",
      "Ridge Mean squared error: 9.16\n",
      "R2:0.629649\n",
      "--------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "alpha = 200\n",
    "ridge = Ridge(alpha=alpha)# 正则项的程度\n",
    "ridge.fit(X_train, y_train)\n",
    "y_pred = ridge.predict(X_test)\n",
    "print(\"测试集得分：\\n {0}\".format(ridge.score(X_test,y_test)))\n",
    "print('Ridge Coefficients: \\n', ridge.coef_)\n",
    "print(\"Ridge Mean squared error: %.2f\" % mean_squared_error(y_test, y_pred))\n",
    "print(\"R2:%f\"% r2_score(y_test, y_pred))\n",
    "#print('Ridge MAPE:%.2f' % np.average(np.abs((y_test-y_pred)/y_test)))\n",
    "print('-' * 50)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 网格搜索-岭回归"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.6536445329009712\n",
      "Ridge(alpha=59)\n",
      "{'alpha': 59}\n",
      "测试集最佳得分：\n",
      " 0.6536445329009712\n",
      "Grid Ridge Mean squared error: 9.04\n",
      "--------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "ridge_ = Ridge()\n",
    "# 网格搜索  找到最佳的alpha值，也就是最佳的正则项系数\n",
    "param_alpha = {'alpha': range(10,60,1)}\n",
    "#传入模型和参数\n",
    "grid = GridSearchCV(estimator=ridge_, param_grid=param_alpha) # 网格搜索同时满足了fit，search 和score 的三种功能\n",
    "# 网格搜索会从参数中不断选取对应的参数进行组合，然后自动进行交叉验证，返回每一组参数下交叉验证的\n",
    "grid.fit(X_train, y_train)\n",
    "y_pred = grid.predict(X_test)\n",
    "#输出最佳结果\n",
    "print(grid.best_score_)\n",
    "print(grid.best_estimator_)\n",
    "print(grid.best_params_)\n",
    "\n",
    "print(\"测试集最佳得分：\\n\",grid.best_score_)\n",
    "print(\"Grid Ridge Mean squared error: %.2f\" % mean_squared_error(y_test, y_pred))\n",
    "#print('Grid Ridge MAPE:%.2f' % np.average(np.abs((y_test-y_pred)/y_test)))\n",
    "print('-' * 50)\n",
    "\n",
    "#-------------------绘制学习曲线------------------------#"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 网格搜索 -GBDT算法"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\Program\\anaconda\\lib\\site-packages\\numpy\\core\\fromnumeric.py:87: RuntimeWarning: overflow encountered in reduce\n",
      "  return ufunc.reduce(obj, axis, dtype, out, **passkwargs)\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\numpy\\core\\fromnumeric.py:87: RuntimeWarning: overflow encountered in reduce\n",
      "  return ufunc.reduce(obj, axis, dtype, out, **passkwargs)\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\numpy\\core\\fromnumeric.py:87: RuntimeWarning: overflow encountered in reduce\n",
      "  return ufunc.reduce(obj, axis, dtype, out, **passkwargs)\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\numpy\\core\\fromnumeric.py:87: RuntimeWarning: overflow encountered in reduce\n",
      "  return ufunc.reduce(obj, axis, dtype, out, **passkwargs)\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\metrics\\_regression.py:691: RuntimeWarning: overflow encountered in square\n",
      "  numerator = (weight * (y_true - y_pred) ** 2).sum(axis=0,\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\numpy\\core\\fromnumeric.py:87: RuntimeWarning: overflow encountered in reduce\n",
      "  return ufunc.reduce(obj, axis, dtype, out, **passkwargs)\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\numpy\\core\\fromnumeric.py:87: RuntimeWarning: overflow encountered in reduce\n",
      "  return ufunc.reduce(obj, axis, dtype, out, **passkwargs)\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\numpy\\core\\fromnumeric.py:87: RuntimeWarning: overflow encountered in reduce\n",
      "  return ufunc.reduce(obj, axis, dtype, out, **passkwargs)\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\numpy\\core\\fromnumeric.py:87: RuntimeWarning: overflow encountered in reduce\n",
      "  return ufunc.reduce(obj, axis, dtype, out, **passkwargs)\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\numpy\\core\\fromnumeric.py:87: RuntimeWarning: overflow encountered in reduce\n",
      "  return ufunc.reduce(obj, axis, dtype, out, **passkwargs)\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\metrics\\_regression.py:691: RuntimeWarning: overflow encountered in square\n",
      "  numerator = (weight * (y_true - y_pred) ** 2).sum(axis=0,\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\numpy\\core\\fromnumeric.py:87: RuntimeWarning: overflow encountered in reduce\n",
      "  return ufunc.reduce(obj, axis, dtype, out, **passkwargs)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\Program\\anaconda\\lib\\site-packages\\numpy\\core\\fromnumeric.py:87: RuntimeWarning: overflow encountered in reduce\n",
      "  return ufunc.reduce(obj, axis, dtype, out, **passkwargs)\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\numpy\\core\\fromnumeric.py:87: RuntimeWarning: overflow encountered in reduce\n",
      "  return ufunc.reduce(obj, axis, dtype, out, **passkwargs)\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\numpy\\core\\fromnumeric.py:87: RuntimeWarning: overflow encountered in reduce\n",
      "  return ufunc.reduce(obj, axis, dtype, out, **passkwargs)\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\numpy\\core\\fromnumeric.py:87: RuntimeWarning: overflow encountered in reduce\n",
      "  return ufunc.reduce(obj, axis, dtype, out, **passkwargs)\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\metrics\\_regression.py:691: RuntimeWarning: overflow encountered in square\n",
      "  numerator = (weight * (y_true - y_pred) ** 2).sum(axis=0,\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\numpy\\core\\fromnumeric.py:87: RuntimeWarning: overflow encountered in reduce\n",
      "  return ufunc.reduce(obj, axis, dtype, out, **passkwargs)\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\numpy\\core\\fromnumeric.py:87: RuntimeWarning: overflow encountered in reduce\n",
      "  return ufunc.reduce(obj, axis, dtype, out, **passkwargs)\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\numpy\\core\\fromnumeric.py:87: RuntimeWarning: overflow encountered in reduce\n",
      "  return ufunc.reduce(obj, axis, dtype, out, **passkwargs)\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\numpy\\core\\fromnumeric.py:87: RuntimeWarning: overflow encountered in reduce\n",
      "  return ufunc.reduce(obj, axis, dtype, out, **passkwargs)\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\metrics\\_regression.py:691: RuntimeWarning: overflow encountered in square\n",
      "  numerator = (weight * (y_true - y_pred) ** 2).sum(axis=0,\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\Program\\anaconda\\lib\\site-packages\\numpy\\core\\fromnumeric.py:87: RuntimeWarning: overflow encountered in reduce\n",
      "  return ufunc.reduce(obj, axis, dtype, out, **passkwargs)\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\numpy\\core\\fromnumeric.py:87: RuntimeWarning: overflow encountered in reduce\n",
      "  return ufunc.reduce(obj, axis, dtype, out, **passkwargs)\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\numpy\\core\\fromnumeric.py:87: RuntimeWarning: overflow encountered in reduce\n",
      "  return ufunc.reduce(obj, axis, dtype, out, **passkwargs)\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\numpy\\core\\fromnumeric.py:87: RuntimeWarning: overflow encountered in reduce\n",
      "  return ufunc.reduce(obj, axis, dtype, out, **passkwargs)\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\numpy\\core\\fromnumeric.py:87: RuntimeWarning: overflow encountered in reduce\n",
      "  return ufunc.reduce(obj, axis, dtype, out, **passkwargs)\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb_losses.py:202: RuntimeWarning: overflow encountered in square\n",
      "  sample_weight * ((y - raw_predictions.ravel()) ** 2)))\n",
      "D:\\Program\\anaconda\\lib\\site-packages\\sklearn\\metrics\\_regression.py:691: RuntimeWarning: overflow encountered in square\n",
      "  numerator = (weight * (y_true - y_pred) ** 2).sum(axis=0,\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-75-088e2dbf4418>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[0mgbdt\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mensemble\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mGradientBoostingRegressor\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[0mgrid\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mGridSearchCV\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mestimator\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mgbdt\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mparam_grid\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mparams\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 5\u001b[1;33m \u001b[0mgrid\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mX_train\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0my_train\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      6\u001b[0m \u001b[0my_pred\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mgrid\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mpredict\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mX_test\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      7\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mgrid\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mbest_score_\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mD:\\Program\\anaconda\\lib\\site-packages\\sklearn\\utils\\validation.py\u001b[0m in \u001b[0;36minner_f\u001b[1;34m(*args, **kwargs)\u001b[0m\n\u001b[0;32m     61\u001b[0m             \u001b[0mextra_args\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m-\u001b[0m \u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mall_args\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     62\u001b[0m             \u001b[1;32mif\u001b[0m \u001b[0mextra_args\u001b[0m \u001b[1;33m<=\u001b[0m \u001b[1;36m0\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 63\u001b[1;33m                 \u001b[1;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     64\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     65\u001b[0m             \u001b[1;31m# extra_args > 0\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mD:\\Program\\anaconda\\lib\\site-packages\\sklearn\\model_selection\\_search.py\u001b[0m in \u001b[0;36mfit\u001b[1;34m(self, X, y, groups, **fit_params)\u001b[0m\n\u001b[0;32m    839\u001b[0m                 \u001b[1;32mreturn\u001b[0m \u001b[0mresults\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    840\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 841\u001b[1;33m             \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_run_search\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mevaluate_candidates\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    842\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    843\u001b[0m             \u001b[1;31m# multimetric is determined here because in the case of a callable\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mD:\\Program\\anaconda\\lib\\site-packages\\sklearn\\model_selection\\_search.py\u001b[0m in \u001b[0;36m_run_search\u001b[1;34m(self, evaluate_candidates)\u001b[0m\n\u001b[0;32m   1286\u001b[0m     \u001b[1;32mdef\u001b[0m \u001b[0m_run_search\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mevaluate_candidates\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1287\u001b[0m         \u001b[1;34m\"\"\"Search all candidates in param_grid\"\"\"\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 1288\u001b[1;33m         \u001b[0mevaluate_candidates\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mParameterGrid\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mparam_grid\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   1289\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1290\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mD:\\Program\\anaconda\\lib\\site-packages\\sklearn\\model_selection\\_search.py\u001b[0m in \u001b[0;36mevaluate_candidates\u001b[1;34m(candidate_params, cv, more_results)\u001b[0m\n\u001b[0;32m    793\u001b[0m                               n_splits, n_candidates, n_candidates * n_splits))\n\u001b[0;32m    794\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 795\u001b[1;33m                 out = parallel(delayed(_fit_and_score)(clone(base_estimator),\n\u001b[0m\u001b[0;32m    796\u001b[0m                                                        \u001b[0mX\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0my\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    797\u001b[0m                                                        \u001b[0mtrain\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mtrain\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtest\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mtest\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mD:\\Program\\anaconda\\lib\\site-packages\\joblib\\parallel.py\u001b[0m in \u001b[0;36m__call__\u001b[1;34m(self, iterable)\u001b[0m\n\u001b[0;32m   1042\u001b[0m                 \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_iterating\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_original_iterator\u001b[0m \u001b[1;32mis\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1043\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 1044\u001b[1;33m             \u001b[1;32mwhile\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdispatch_one_batch\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0miterator\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   1045\u001b[0m                 \u001b[1;32mpass\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1046\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mD:\\Program\\anaconda\\lib\\site-packages\\joblib\\parallel.py\u001b[0m in \u001b[0;36mdispatch_one_batch\u001b[1;34m(self, iterator)\u001b[0m\n\u001b[0;32m    857\u001b[0m                 \u001b[1;32mreturn\u001b[0m \u001b[1;32mFalse\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    858\u001b[0m             \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 859\u001b[1;33m                 \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_dispatch\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtasks\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    860\u001b[0m                 \u001b[1;32mreturn\u001b[0m \u001b[1;32mTrue\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    861\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mD:\\Program\\anaconda\\lib\\site-packages\\joblib\\parallel.py\u001b[0m in \u001b[0;36m_dispatch\u001b[1;34m(self, batch)\u001b[0m\n\u001b[0;32m    775\u001b[0m         \u001b[1;32mwith\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_lock\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    776\u001b[0m             \u001b[0mjob_idx\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_jobs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 777\u001b[1;33m             \u001b[0mjob\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_backend\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mapply_async\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mbatch\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mcallback\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mcb\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    778\u001b[0m             \u001b[1;31m# A job can complete so quickly than its callback is\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    779\u001b[0m             \u001b[1;31m# called before we get here, causing self._jobs to\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mD:\\Program\\anaconda\\lib\\site-packages\\joblib\\_parallel_backends.py\u001b[0m in \u001b[0;36mapply_async\u001b[1;34m(self, func, callback)\u001b[0m\n\u001b[0;32m    206\u001b[0m     \u001b[1;32mdef\u001b[0m \u001b[0mapply_async\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mfunc\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mcallback\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mNone\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    207\u001b[0m         \u001b[1;34m\"\"\"Schedule a func to be run\"\"\"\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 208\u001b[1;33m         \u001b[0mresult\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mImmediateResult\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mfunc\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    209\u001b[0m         \u001b[1;32mif\u001b[0m \u001b[0mcallback\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    210\u001b[0m             \u001b[0mcallback\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mresult\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mD:\\Program\\anaconda\\lib\\site-packages\\joblib\\_parallel_backends.py\u001b[0m in \u001b[0;36m__init__\u001b[1;34m(self, batch)\u001b[0m\n\u001b[0;32m    570\u001b[0m         \u001b[1;31m# Don't delay the application, to avoid keeping the input\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    571\u001b[0m         \u001b[1;31m# arguments in memory\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 572\u001b[1;33m         \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mresults\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mbatch\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    573\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    574\u001b[0m     \u001b[1;32mdef\u001b[0m \u001b[0mget\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mD:\\Program\\anaconda\\lib\\site-packages\\joblib\\parallel.py\u001b[0m in \u001b[0;36m__call__\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m    260\u001b[0m         \u001b[1;31m# change the default number of processes to -1\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    261\u001b[0m         \u001b[1;32mwith\u001b[0m \u001b[0mparallel_backend\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_backend\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mn_jobs\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_n_jobs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 262\u001b[1;33m             return [func(*args, **kwargs)\n\u001b[0m\u001b[0;32m    263\u001b[0m                     for func, args, kwargs in self.items]\n\u001b[0;32m    264\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mD:\\Program\\anaconda\\lib\\site-packages\\joblib\\parallel.py\u001b[0m in \u001b[0;36m<listcomp>\u001b[1;34m(.0)\u001b[0m\n\u001b[0;32m    260\u001b[0m         \u001b[1;31m# change the default number of processes to -1\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    261\u001b[0m         \u001b[1;32mwith\u001b[0m \u001b[0mparallel_backend\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_backend\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mn_jobs\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_n_jobs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 262\u001b[1;33m             return [func(*args, **kwargs)\n\u001b[0m\u001b[0;32m    263\u001b[0m                     for func, args, kwargs in self.items]\n\u001b[0;32m    264\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mD:\\Program\\anaconda\\lib\\site-packages\\sklearn\\utils\\fixes.py\u001b[0m in \u001b[0;36m__call__\u001b[1;34m(self, *args, **kwargs)\u001b[0m\n\u001b[0;32m    220\u001b[0m     \u001b[1;32mdef\u001b[0m \u001b[0m__call__\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    221\u001b[0m         \u001b[1;32mwith\u001b[0m \u001b[0mconfig_context\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m**\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mconfig\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 222\u001b[1;33m             \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfunction\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;32mD:\\Program\\anaconda\\lib\\site-packages\\sklearn\\model_selection\\_validation.py\u001b[0m in \u001b[0;36m_fit_and_score\u001b[1;34m(estimator, X, y, scorer, train, test, verbose, parameters, fit_params, return_train_score, return_parameters, return_n_test_samples, return_times, return_estimator, split_progress, candidate_progress, error_score)\u001b[0m\n\u001b[0;32m    591\u001b[0m             \u001b[0mestimator\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mX_train\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mfit_params\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    592\u001b[0m         \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 593\u001b[1;33m             \u001b[0mestimator\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mX_train\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0my_train\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mfit_params\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    594\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    595\u001b[0m     \u001b[1;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[1;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mD:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb.py\u001b[0m in \u001b[0;36mfit\u001b[1;34m(self, X, y, sample_weight, monitor)\u001b[0m\n\u001b[0;32m    502\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    503\u001b[0m         \u001b[1;31m# fit the boosting stages\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 504\u001b[1;33m         n_stages = self._fit_stages(\n\u001b[0m\u001b[0;32m    505\u001b[0m             \u001b[0mX\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0my\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mraw_predictions\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0msample_weight\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_rng\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mX_val\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0my_val\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    506\u001b[0m             sample_weight_val, begin_at_stage, monitor)\n",
      "\u001b[1;32mD:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb.py\u001b[0m in \u001b[0;36m_fit_stages\u001b[1;34m(self, X, y, raw_predictions, sample_weight, random_state, X_val, y_val, sample_weight_val, begin_at_stage, monitor)\u001b[0m\n\u001b[0;32m    559\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    560\u001b[0m             \u001b[1;31m# fit next stage of trees\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 561\u001b[1;33m             raw_predictions = self._fit_stage(\n\u001b[0m\u001b[0;32m    562\u001b[0m                 \u001b[0mi\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mX\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0my\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mraw_predictions\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0msample_weight\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0msample_mask\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    563\u001b[0m                 random_state, X_csc, X_csr)\n",
      "\u001b[1;32mD:\\Program\\anaconda\\lib\\site-packages\\sklearn\\ensemble\\_gb.py\u001b[0m in \u001b[0;36m_fit_stage\u001b[1;34m(self, i, X, y, raw_predictions, sample_weight, sample_mask, random_state, X_csc, X_csr)\u001b[0m\n\u001b[0;32m    212\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    213\u001b[0m             \u001b[0mX\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mX_csr\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0mX_csr\u001b[0m \u001b[1;32mis\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[1;32mNone\u001b[0m \u001b[1;32melse\u001b[0m \u001b[0mX\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 214\u001b[1;33m             tree.fit(X, residual, sample_weight=sample_weight,\n\u001b[0m\u001b[0;32m    215\u001b[0m                      check_input=False)\n\u001b[0;32m    216\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mD:\\Program\\anaconda\\lib\\site-packages\\sklearn\\tree\\_classes.py\u001b[0m in \u001b[0;36mfit\u001b[1;34m(self, X, y, sample_weight, check_input, X_idx_sorted)\u001b[0m\n\u001b[0;32m   1245\u001b[0m         \"\"\"\n\u001b[0;32m   1246\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 1247\u001b[1;33m         super().fit(\n\u001b[0m\u001b[0;32m   1248\u001b[0m             \u001b[0mX\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0my\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1249\u001b[0m             \u001b[0msample_weight\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0msample_weight\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mD:\\Program\\anaconda\\lib\\site-packages\\sklearn\\tree\\_classes.py\u001b[0m in \u001b[0;36mfit\u001b[1;34m(self, X, y, sample_weight, check_input, X_idx_sorted)\u001b[0m\n\u001b[0;32m    387\u001b[0m                                            min_impurity_split)\n\u001b[0;32m    388\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 389\u001b[1;33m         \u001b[0mbuilder\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mbuild\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mtree_\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mX\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0my\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0msample_weight\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    390\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    391\u001b[0m         \u001b[1;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mn_outputs_\u001b[0m \u001b[1;33m==\u001b[0m \u001b[1;36m1\u001b[0m \u001b[1;32mand\u001b[0m \u001b[0mis_classifier\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "params = {'n_estimators':[100, 1000], 'max_depth':[2], 'min_samples_split': [2], 'learning_rate':[3, 1, 0.1, 0.3], 'loss': ['ls']}\n",
    "gbdt = ensemble.GradientBoostingRegressor()\n",
    "grid = GridSearchCV(estimator=gbdt,param_grid=params)\n",
    "grid.fit(X_train, y_train)\n",
    "y_pred = grid.predict(X_test)\n",
    "print(grid.best_score_)\n",
    "print(grid.best_estimator_)\n",
    "print(grid.best_params_)\n",
    "\n",
    "print(\"测试集最佳得分：\\n\",grid.best_score_)\n",
    "print(\"Grid GBDT Mean squared error: %.2f\" % mean_squared_error(y_test, y_pred))\n",
    "print('Grid GBDT Variance score: %.2f' % ridge.score(X_test, y_test))\n",
    "print('Grid GBDT MAPE:%.2f' % np.average(np.abs((y_test-y_pred)/y_test)))\n",
    "print('-' * 50)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 网格搜索- 随机森林算法"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.684059164138964\n",
      "RandomForestRegressor(max_depth=100, max_features=10, n_estimators=62)\n",
      "{'max_depth': 100, 'max_features': 10, 'n_estimators': 62}\n",
      "测试集最佳得分：\n",
      " 0.684059164138964\n",
      "Grid RF Mean squared error: 9.10\n",
      "Grid RF Variance score: 0.63\n",
      "Grid RF MAPE:inf\n",
      "--------------------------------------------------\n",
      "Wall time: 4min 52s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<timed exec>:13: RuntimeWarning: divide by zero encountered in true_divide\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "rf = ensemble.RandomForestRegressor()\n",
    "params = {'n_estimators': range(50,70,1), 'max_depth':[10, 50, 100], 'max_features':[2, 5, 10]}\n",
    "grid = GridSearchCV(estimator=rf, param_grid=params)\n",
    "grid.fit(X_train, y_train)\n",
    "y_pred = grid.predict(X_test)\n",
    "print(grid.best_score_)\n",
    "print(grid.best_estimator_)\n",
    "print(grid.best_params_)\n",
    "\n",
    "print(\"测试集最佳得分：\\n\",grid.best_score_)\n",
    "print(\"Grid RF Mean squared error: %.2f\" % mean_squared_error(y_test, y_pred))\n",
    "print('Grid RF Variance score: %.2f' % ridge.score(X_test, y_test))\n",
    "print('Grid RF MAPE:%.2f' % np.average(np.abs((y_test-y_pred)/y_test)))\n",
    "print('-' * 50)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 网格搜索xboost 算法"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "测试集最佳得分：\n",
      " 0.7344704647193986\n",
      "Grid xgboost Mean squared error: 7.46\n",
      "Grid xgboost MAPE:inf\n",
      "--------------------------------------------------\n",
      "Wall time: 14min 37s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<timed exec>:8: RuntimeWarning: divide by zero encountered in true_divide\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "model = xgb.XGBRegressor()\n",
    "params = {'n_estimators': [100, 150, 160], 'learning_rate': [0.1, 0.5, 1.0]}\n",
    "grid = GridSearchCV(estimator=model, param_grid=params)\n",
    "grid.fit(X_train, y_train)\n",
    "y_pred = grid.predict(X_test)\n",
    "print(\"测试集最佳得分：\\n\",grid.best_score_)\n",
    "print(\"Grid xgboost Mean squared error: %.2f\" % mean_squared_error(y_test, y_pred))\n",
    "print('Grid xgboost MAPE:%.2f' % np.average(np.abs((y_test-y_pred)/y_test)))\n",
    "print('-' * 50)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
